Foros Club Delphi - Colocar Hardware BreakPoints en Windows x64

Bueno amigos, esto avanza poquito a poquito. Ahora me encuentro con el tema de los Hardware BreakPoints los cuales al pasar el codigo a x64 no funcionan y ademas el programa depurado da una excepcion y se acaba cerrando.
Para ponerlos en x32 tenia estas constantes:

Código PHP:


		
			
#define EXCEPTION_GUARD_PAGE_VIOLATION 0x80000001L



enum ModeBPM { BMP_WRITE, BMP_ACCESS,BMP_EXECUTION};

enum ModeHW { HW_WRITE, HW_ACCESS, HW_EXECUTION};

enum LenHW { HW_BYTE, HW_WORD, HW_DWORD};



//Constantes para los HW

#define HW_DR0        0x1

#define HW_DR1        0x2

#define HW_DR2        0x3

#define HW_DR3        0x4



#define DR0_LOCAL_EXACT_BPM_ENABLED    0x01

#define DR0_GLOBAL_EXACT_BPM_ENABLED   0x02



#define DR0_W      0x10000

#define DR0_IO      0x20000

#define DR0_RW          0x30000

#define DR0_EXECUTION    0x0



#define DR0_LEN1    0x0

#define DR0_LEN2    0x40000

#define DR0_LEN3    0x0C0000



#define DR1_LOCAL_EXACT_BPM_ENABLED  0x4

#define DR1_GLOBAL_EXACT_BPM_ENABLED 0x8



#define DR1_W      0x100000

#define DR1_IO      0x200000

#define DR1_RW      0x300000

#define DR1_EXECUTION          0x0



#define DR1_LEN1    0x0

#define DR1_LEN2    0x400000

#define DR1_LEN3    0x0C00000



#define DR2_LOCAL_EXACT_BPM_ENABLED  0x10

#define DR2_GLOBAL_EXACT_BPM_ENABLED 0x20



#define DR2_W      0x1000000

#define DR2_IO      0x2000000

#define DR2_RW      0x3000000

#define DR2_EXECUTION          0x0



#define DR2_LEN1    0x0

#define DR2_LEN2    0x4000000

#define DR2_LEN3    0x0C000000



#define DR3_LOCAL_EXACT_BPM_ENABLED   0x40

#define DR3_GLOBAL_EXACT_BPM_ENABLED  0x80



#define DR3_W      0x10000000

#define DR3_IO      0x20000000

#define DR3_RW      0x30000000

#define DR3_EXECUTION          0x0



#define DR3_LEN1    0x0

#define DR3_LEN2    0x40000000

#define DR3_LEN3    0x0C0000000



#define LOCAL_EXACT_BPM_ENABLED      0x100

#define LOCAL_EXACT_BPM_DISABLED    0x0

#define GLOBAL_EXACT_BPM_ENABLED    0x200

#define GLOBAL_EXACT_BPM_DISABLED   0x0

#define GENERAL_DETECT_ENABLED      0x2000

#define RESERVED_BIT10              0x400



#define CLEAR_DR0            0x0FFF0FFFC

#define CLEAR_DR1               0x0FF0FFFF3

#define CLEAR_DR2                   0x0F0FFFFCF

#define CLEAR_DR3                   0x0FFFFF3F

Y esta funcion:

Código PHP:


		
			
DWORD __fastcall THiloDebugger::OnSingleStepEventThread(EXCEPTION_DEBUG_INFO *info)

{

    pBP BPaux;

    int HWBySingleStep=0;



    DWORD Aux;



     /*-------------------------------------------------------------------------------------

    *

    * DEBUG REGISTER 7

    *

    * LEN3 R/W3 LEN2 R/W2 LEN1 R/W1 LEN0 R/W0 0 0 GD 0 0 1 GE LE G3 L3 G2 L2 G1 L1 G0 L0

    *

    *  00   00   00   00   00   00   00   00  0 0 0  0 0 0 0  1  0  1  0  1  0  1  0  1

    *

    *-------------------------------------------------------------------------------------*/



    if(RepairHW == true){

        switch(ItemHWRepair.DrW){



            case HW_DR0:

                con.Dr0 = ItemHWRepair.Address;

                break;



            case HW_DR1:

                con.Dr1 = ItemHWRepair.Address;

                break;



            case HW_DR2:

                con.Dr2 = ItemHWRepair.Address;

                break;



            case HW_DR3:

                con.Dr3 = ItemHWRepair.Address;

                break;



        }

        RepairHW = false;



        if(UserStepIn == true){

            UserStepIn = false;



            DisableBP(0); // Desactivamos todos los BPs para que si el usuario ve la memoria esta se muestre como debe

            ClearBMP(true); // reponemos las propiedades de la memoria



            Synchronize(SingleStepInSincronyze);

        }

    }

    else{



        // Verificamos si la parada fue por un HW

        if (con.Dr6 & 1) {

            HWBySingleStep = HW_DR0;

        }

        else if(con.Dr6 & 2){

            HWBySingleStep = HW_DR1;

        }

        else if(con.Dr6 & 4){

            HWBySingleStep = HW_DR2;

        }

        else if(con.Dr6 & 8){

            HWBySingleStep = HW_DR3;

        }



        if (HWBySingleStep != 0) {

            UserStepIn = false;

            // el sigle step fue originado por un HW

            DisableBP(0); // Desactivamos todos los BPs para que si el usuario ve la memoria esta se muestre como debe

            ClearBMP(true); // reponemos las propiedades de la memoria



            Aux = con.Dr7;

            switch(HWBySingleStep){



                case HW_DR0:

                        HWAddress = con.Dr0;

                        Aux >>=  16;

                        break;

                case HW_DR1:

                        HWAddress = con.Dr1;

                        Aux >>=  20;

                        break;

                case HW_DR2:

                        HWAddress = con.Dr2;

                        Aux >>= 24;

                        break;

                case HW_DR3:

                        HWAddress = con.Dr3;

                        Aux >>= 28;

                        break;



            }

            Aux &= 3;

            if( Aux == 00){ // por ejecución

                LastHWMode = HW_EXECUTION;

            }

            else if(Aux ==01){

                LastHWMode = HW_WRITE;

            }

            else{

                LastHWMode = HW_ACCESS;

            }



            // llamar al usuario

            Synchronize(HardwareBreakPointSincronyze);





            switch(HWBySingleStep){



                case HW_DR0:



                    if(con.Dr0 == LastExceptionAddress){ // por ejecución



                        ItemHWRepair.Address = LastExceptionAddress;

                        ItemHWRepair.DrW = HW_DR0;

                        con.Dr0 = 0; // hay que guardar el dato

                        RepairHW=true;

                    }

                    break;

                case HW_DR1:

                    if(con.Dr1 == LastExceptionAddress){ // por ejecución



                        ItemHWRepair.Address = LastExceptionAddress;

                        ItemHWRepair.DrW = HW_DR1;



                        con.Dr1 = 0; // hay que guardar el dato

                        RepairHW= true;



                    }

                    break;

                case HW_DR2:

                    if(con.Dr2 == LastExceptionAddress){ // por ejecución



                        ItemHWRepair.Address = LastExceptionAddress;

                        ItemHWRepair.DrW = HW_DR2;



                        con.Dr2 = 0; // hay que guardar el dato

                        RepairHW= true;



                    }

                    break;

                case HW_DR3:

                    if(con.Dr3 == LastExceptionAddress){ // por ejecución



                        ItemHWRepair.Address = LastExceptionAddress;

                        ItemHWRepair.DrW = HW_DR3;



                        con.Dr3 = 0; // hay que guardar el dato

                        RepairHW= true;



                    }

                    break;

            }

            if(RepairHW== true){

                SetSingleStep();

            }



        }

        else if( UserStepIn == true){

            UserStepIn = false;

            DisableBP(0); // Desactivamos todos los BPs para que si el usuario ve la memoria esta se muestre como debe

            ClearBMP(true); // reponemos las propiedades de la memoria



            Synchronize(SingleStepInSincronyze);



        }



         if(ItemBMP.Address != NULL){  // La excepción no fue por un BMP

            SetBMP(ItemBMP.Address,ItemBMP.Size,ItemBMP.Mode);

        }



        // Reponemos los BPs

        for(int i=0; i < ListaBPs->Count;i++){

            BPaux = (TBP*)ListaBPs->Items[i];

            if(BPaux->estado == false){

                SetBP(BPaux->dir);

            }

        }

    }

    return DBG_CONTINUE; // exception continuation



}

El caso es que no se si los valores a usar en x64 son diferentes a los que se usan en x32. ¿Pueden echarme una mano?