sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Import SourceLevelDebugPkg.

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@10867 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
vanjeff
2010-09-12 06:43:36 +00:00
parent bf45bbe53d
commit 18b144ea42
44 changed files with 8949 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
SourceLevelDebugPkg/Include/Guid/DebugAgentGuid.h Normal file
View File

@@ -0,0 +1,32 @@
/** @file
This file defines the debug agent GUID for HOB and configuration table.
Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __EFI_DEBUG_AGNET_GUID_H__
#define __EFI_DEBUG_AGENT_GUID_H__
///
/// This guid is used as a variable GUID for the capsule variable
/// if the capsule pointer is passed through reset via a variable.
///
/// This guid is also used as a hob GUID for the capsule data
/// when the capsule pointer is passed from PEI phase to DXE phase.
///
#define EFI_DEBUG_AGENT_GUID \
{ \
0x865a5a9b, 0xb85d, 0x474c, { 0x84, 0x55, 0x65, 0xd1, 0xbe, 0x84, 0x4b, 0xe2 } \
}
extern EFI_GUID gEfiDebugAgentGuid;
#endif

179
SourceLevelDebugPkg/Include/Ia32/ProcessorContext.h Normal file
View File

@@ -0,0 +1,179 @@
/** @file
IA32/x64 architecture specific defintions needed by debug transfer protocol.It is only
intended to be used by Debug related module implementation.
Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __PROCESSOR_CONTEXT_H__
#define __PROCESSOR_CONTEXT_H__
//
// IA-32/x64 processor register index table
//
#define SOFT_DEBUGGER_REGISTER_DR0 0
#define SOFT_DEBUGGER_REGISTER_DR1 1
#define SOFT_DEBUGGER_REGISTER_DR2 2
#define SOFT_DEBUGGER_REGISTER_DR3 3
#define SOFT_DEBUGGER_REGISTER_DR6 4
#define SOFT_DEBUGGER_REGISTER_DR7 5
#define SOFT_DEBUGGER_REGISTER_EFLAGS 6
#define SOFT_DEBUGGER_REGISTER_LDTR 7
#define SOFT_DEBUGGER_REGISTER_TR 8
#define SOFT_DEBUGGER_REGISTER_GDTR0 9 // the low 32bit of GDTR
#define SOFT_DEBUGGER_REGISTER_GDTR1 10 // the high 32bit of GDTR
#define SOFT_DEBUGGER_REGISTER_IDTR0 11 // the low 32bit of IDTR
#define SOFT_DEBUGGER_REGISTER_IDTR1 12 // the high 32bot of IDTR
#define SOFT_DEBUGGER_REGISTER_EIP 13
#define SOFT_DEBUGGER_REGISTER_GS 14
#define SOFT_DEBUGGER_REGISTER_FS 15
#define SOFT_DEBUGGER_REGISTER_ES 16
#define SOFT_DEBUGGER_REGISTER_DS 17
#define SOFT_DEBUGGER_REGISTER_CS 18
#define SOFT_DEBUGGER_REGISTER_SS 19
#define SOFT_DEBUGGER_REGISTER_CR0 20
#define SOFT_DEBUGGER_REGISTER_CR1 21
#define SOFT_DEBUGGER_REGISTER_CR2 22
#define SOFT_DEBUGGER_REGISTER_CR3 23
#define SOFT_DEBUGGER_REGISTER_CR4 24
#define SOFT_DEBUGGER_REGISTER_DI 25
#define SOFT_DEBUGGER_REGISTER_SI 26
#define SOFT_DEBUGGER_REGISTER_BP 27
#define SOFT_DEBUGGER_REGISTER_SP 28
#define SOFT_DEBUGGER_REGISTER_DX 29
#define SOFT_DEBUGGER_REGISTER_CX 30
#define SOFT_DEBUGGER_REGISTER_BX 31
#define SOFT_DEBUGGER_REGISTER_AX 32
//
// This below registers are only available for x64 (not valid for Ia32 mode)
//
#define SOFT_DEBUGGER_REGISTER_CR8 33
#define SOFT_DEBUGGER_REGISTER_R8 34
#define SOFT_DEBUGGER_REGISTER_R9 35
#define SOFT_DEBUGGER_REGISTER_R10 36
#define SOFT_DEBUGGER_REGISTER_R11 37
#define SOFT_DEBUGGER_REGISTER_R12 38
#define SOFT_DEBUGGER_REGISTER_R13 39
#define SOFT_DEBUGGER_REGISTER_R14 40
#define SOFT_DEBUGGER_REGISTER_R15 41
#define SOFT_DEBUGGER_REGISTER_MAX_COUNT_IA32 33
#define SOFT_DEBUGGER_REGISTER_MAX_COUNT_X64 42
//
// This below registers are FP / MMX / XMM registers
//
#define SOFT_DEBUGGER_REGISTER_FP_BASE 50
#define SOFT_DEBUGGER_REGISTER_FP_FCW (SOFT_DEBUGGER_REGISTER_FP_BASE + 0)
#define SOFT_DEBUGGER_REGISTER_FP_FSW (SOFT_DEBUGGER_REGISTER_FP_BASE + 1)
#define SOFT_DEBUGGER_REGISTER_FP_FTW (SOFT_DEBUGGER_REGISTER_FP_BASE + 2)
#define SOFT_DEBUGGER_REGISTER_FP_OPCODE (SOFT_DEBUGGER_REGISTER_FP_BASE + 3)
#define SOFT_DEBUGGER_REGISTER_FP_EIP (SOFT_DEBUGGER_REGISTER_FP_BASE + 4)
#define SOFT_DEBUGGER_REGISTER_FP_CS (SOFT_DEBUGGER_REGISTER_FP_BASE + 5)
#define SOFT_DEBUGGER_REGISTER_FP_DATAOFFSET (SOFT_DEBUGGER_REGISTER_FP_BASE + 6)
#define SOFT_DEBUGGER_REGISTER_FP_DS (SOFT_DEBUGGER_REGISTER_FP_BASE + 7)
#define SOFT_DEBUGGER_REGISTER_FP_MXCSR (SOFT_DEBUGGER_REGISTER_FP_BASE + 8)
#define SOFT_DEBUGGER_REGISTER_FP_MXCSR_MASK (SOFT_DEBUGGER_REGISTER_FP_BASE + 9)
#define SOFT_DEBUGGER_REGISTER_ST0 (SOFT_DEBUGGER_REGISTER_FP_BASE + 10)
#define SOFT_DEBUGGER_REGISTER_ST1 (SOFT_DEBUGGER_REGISTER_FP_BASE + 11)
#define SOFT_DEBUGGER_REGISTER_ST2 (SOFT_DEBUGGER_REGISTER_FP_BASE + 12)
#define SOFT_DEBUGGER_REGISTER_ST3 (SOFT_DEBUGGER_REGISTER_FP_BASE + 13)
#define SOFT_DEBUGGER_REGISTER_ST4 (SOFT_DEBUGGER_REGISTER_FP_BASE + 14)
#define SOFT_DEBUGGER_REGISTER_ST5 (SOFT_DEBUGGER_REGISTER_FP_BASE + 15)
#define SOFT_DEBUGGER_REGISTER_ST6 (SOFT_DEBUGGER_REGISTER_FP_BASE + 16)
#define SOFT_DEBUGGER_REGISTER_ST7 (SOFT_DEBUGGER_REGISTER_FP_BASE + 17)
#define SOFT_DEBUGGER_REGISTER_XMM0 (SOFT_DEBUGGER_REGISTER_FP_BASE + 18)
#define SOFT_DEBUGGER_REGISTER_XMM1 (SOFT_DEBUGGER_REGISTER_FP_BASE + 19)
#define SOFT_DEBUGGER_REGISTER_XMM2 (SOFT_DEBUGGER_REGISTER_FP_BASE + 20)
#define SOFT_DEBUGGER_REGISTER_XMM3 (SOFT_DEBUGGER_REGISTER_FP_BASE + 21)
#define SOFT_DEBUGGER_REGISTER_XMM4 (SOFT_DEBUGGER_REGISTER_FP_BASE + 22)
#define SOFT_DEBUGGER_REGISTER_XMM5 (SOFT_DEBUGGER_REGISTER_FP_BASE + 23)
#define SOFT_DEBUGGER_REGISTER_XMM6 (SOFT_DEBUGGER_REGISTER_FP_BASE + 24)
#define SOFT_DEBUGGER_REGISTER_XMM7 (SOFT_DEBUGGER_REGISTER_FP_BASE + 25)
#define SOFT_DEBUGGER_REGISTER_XMM8 (SOFT_DEBUGGER_REGISTER_FP_BASE + 26)
#define SOFT_DEBUGGER_REGISTER_XMM9 (SOFT_DEBUGGER_REGISTER_FP_BASE + 27)
#define SOFT_DEBUGGER_REGISTER_XMM10 (SOFT_DEBUGGER_REGISTER_FP_BASE + 28)
#define SOFT_DEBUGGER_REGISTER_XMM11 (SOFT_DEBUGGER_REGISTER_FP_BASE + 29)
#define SOFT_DEBUGGER_REGISTER_XMM12 (SOFT_DEBUGGER_REGISTER_FP_BASE + 30)
#define SOFT_DEBUGGER_REGISTER_XMM13 (SOFT_DEBUGGER_REGISTER_FP_BASE + 31)
#define SOFT_DEBUGGER_REGISTER_XMM14 (SOFT_DEBUGGER_REGISTER_FP_BASE + 32)
#define SOFT_DEBUGGER_REGISTER_XMM15 (SOFT_DEBUGGER_REGISTER_FP_BASE + 33)
#define SOFT_DEBUGGER_REGISTER_MM0 (SOFT_DEBUGGER_REGISTER_FP_BASE + 34)
#define SOFT_DEBUGGER_REGISTER_MM1 (SOFT_DEBUGGER_REGISTER_FP_BASE + 35)
#define SOFT_DEBUGGER_REGISTER_MM2 (SOFT_DEBUGGER_REGISTER_FP_BASE + 36)
#define SOFT_DEBUGGER_REGISTER_MM3 (SOFT_DEBUGGER_REGISTER_FP_BASE + 37)
#define SOFT_DEBUGGER_REGISTER_MM4 (SOFT_DEBUGGER_REGISTER_FP_BASE + 38)
#define SOFT_DEBUGGER_REGISTER_MM5 (SOFT_DEBUGGER_REGISTER_FP_BASE + 39)
#define SOFT_DEBUGGER_REGISTER_MM6 (SOFT_DEBUGGER_REGISTER_FP_BASE + 40)
#define SOFT_DEBUGGER_REGISTER_MM7 (SOFT_DEBUGGER_REGISTER_FP_BASE + 41)
//
// This below registers are for GDT, LDT, TSS
//
#define SOFT_DEBUGGER_REGISTER_OTHERS_BASE 100
#define SOFT_DEBUGGER_REGISTER_CS_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 0)
#define SOFT_DEBUGGER_REGISTER_SS_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 1)
#define SOFT_DEBUGGER_REGISTER_GS_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 2)
#define SOFT_DEBUGGER_REGISTER_FS_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 3)
#define SOFT_DEBUGGER_REGISTER_ES_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 4)
#define SOFT_DEBUGGER_REGISTER_DS_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 5)
#define SOFT_DEBUGGER_REGISTER_LDT_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 6)
#define SOFT_DEBUGGER_REGISTER_TSS_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 7)
#define SOFT_DEBUGGER_REGISTER_CS_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 8)
#define SOFT_DEBUGGER_REGISTER_SS_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 9)
#define SOFT_DEBUGGER_REGISTER_GS_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 10)
#define SOFT_DEBUGGER_REGISTER_FS_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 11)
#define SOFT_DEBUGGER_REGISTER_ES_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 12)
#define SOFT_DEBUGGER_REGISTER_DS_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 13)
#define SOFT_DEBUGGER_REGISTER_LDT_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 14)
#define SOFT_DEBUGGER_REGISTER_TSS_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 15)
#define SOFT_DEBUGGER_REGISTER_CSAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 16)
#define SOFT_DEBUGGER_REGISTER_SSAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 17)
#define SOFT_DEBUGGER_REGISTER_GSAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 18)
#define SOFT_DEBUGGER_REGISTER_FSAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 19)
#define SOFT_DEBUGGER_REGISTER_ESAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 20)
#define SOFT_DEBUGGER_REGISTER_DSAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 21)
#define SOFT_DEBUGGER_REGISTER_LDTAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 22)
#define SOFT_DEBUGGER_REGISTER_TSSAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 23)
#define SOFT_DEBUGGER_REGISTER_IDT_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 24)
#define SOFT_DEBUGGER_REGISTER_GDT_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 25)
#define SOFT_DEBUGGER_REGISTER_IDT_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 26)
#define SOFT_DEBUGGER_REGISTER_GDT_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 27)
#define SOFT_DEBUGGER_MSR_EFER (0xC0000080)
//
// Definition for the Index field for DEBUG_DATA_READ_REGISTER_GROUP
//
#define SOFT_DEBUGGER_REGISTER_GROUP_GPDRS32 1 //for cs,ds,es,fs,gs,ss,eflags,ebp,eip,esp,eax,ebx,ecx,edx,esi,edi,dr0,dr1,dr2,dr3,dr6,dr7
#define SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT_LIMITS32 2 //for cslim,sslim,gslim,fslim,eslim,dslim,ldtlim,tsslim
#define SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT_BASES32 3 //for csbas,ssbas,gsbas,fsbas,esbas,dsbas,ldtbas,tssbas
#define SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT64 4 //for cs,ds,es,fs,gs,ss
#define SOFT_DEBUGGER_REGISTER_GROUP_GP2_64 5 //for eflags,rbp,rip,rsp
#define SOFT_DEBUGGER_REGISTER_GROUP_GP64 6 //for rax,rbx,rcx,rdx,rsi,rdi,r8,r9,r10,r11,r12,r13,r14,r15
#define SOFT_DEBUGGER_REGISTER_GROUP_DR64 7 //for dr0,dr1,dr2,dr3,dr6,dr7
#define SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT_BAS_LIM64 8 //for ldtbas,ldtlim,gdtbas,gdtlim,cslim,sslim,gslim,fslim,eslim,dslim,ldtlim,tsslim,csbas,ssbas,gsbas,fsbas,esbas,dsbas,ldtbas,tssbas
#define SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT_BASES64 9 //for idtr,tr,csas,ssas,gsas,fsas,esas,dsas,idtas,tssas
#define SOFT_DEBUGGER_REGISTER_GROUP_CR64 10 //for cr0,cr2,cr3,cr4,cr8
#define SOFT_DEBUGGER_REGISTER_GROUP_XMM64 11 //for xmm0,xmm1,xmm2,xmm3,xmm4,xmm5,xmm6,xmm7,xmm8,xmm9,xmm10,xmm11,xmm12,xmm13,xmm14,xmm15
#endif

27
SourceLevelDebugPkg/Include/ImageDebugSupport.h Normal file
View File

@@ -0,0 +1,27 @@
/** @file
Public include file for Debug Agent Library instance and PE/COFF Extra
Action Library instance.
Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __IMAGE_DEBUG_SUPPORT_H__
#define __IMAGE_DEBUG_SUPPORT_H__
#define IO_PORT_BREAKPOINT_ADDRESS 0x84
#define IMAGE_LOAD_SIGNATURE SIGNATURE_32('L','O','A','D')
#define IMAGE_UNLOAD_SIGNATURE SIGNATURE_32('U','N','L','O')
#define DEBUG_AGENT_IMAGE_WAIT 0x00
#define DEBUG_AGENT_IMAGE_CONTINUE 0x01
#endif

152
SourceLevelDebugPkg/Include/Library/DebugCommunicationLib.h Normal file
View File

@@ -0,0 +1,152 @@
/** @file
Debug Communication Library definitions.
Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __DEBUG_COMMUNICATION_LIB_H__
#define __DEBUG_COMMUNICATION_LIB_H__
typedef VOID * DEBUG_PORT_HANDLE;
/**
Caller provided function to be invoked at the end of DebugPortInitialize().
Refer to the descrption for DebugPortInitialize() for more details.
@param[in] Context The first input argument of DebugPortInitialize().
@param[in] DebugPortHandle Debug port handle created by Debug Communication Libary.
**/
typedef
VOID
(EFIAPI * DEBUG_PORT_CONTINUE)(
IN VOID *Context,
IN DEBUG_PORT_HANDLE DebugPortHandle
);
/**
Initialize the debug port.
This function will initialize debug port to get it ready for data transmition. If
certain Debug Communication Library instance has to save some private data in the
stack, this function must work on the mode that doesn't return to the caller, then
the caller needs to wrap up all rest of logic after DebugPortInitialize() into one
function and pass it into DebugPortInitialize(). DebugPortInitialize() is
responsible to invoke the passing-in funciton at the end of DebugPortInitialize().
If the paramter Function is not NULL, Debug Communication Libary instance will
invoke it by passing in the Context to be the first parameter. Debug Communication
Library instance could create one debug port handle to be the second parameter
passing into the Function. Debug Communication Library instance also could pass
NULL to be the second parameter if it doesn't create the debug port handle.
If the parameter Function is NULL, and Context is not NULL. At this time, Context
is the debug port handle created by the previous Debug Communication Library
instance.
a) If the instance can understand and continue use the private data of the previous
instance, it could return the same handle as passed in (as Context parameter).
b) If the instance does not understand, or does not want to continue use the
private data of the previous instance, it could ignore the input Context parameter
and create the new hanlde to be returned.
If Function() is NULL and Context is NULL, Debug Communication Library could create a
new handle and return it. NULL is also a valid handle to be returned.
@param[in] Context Context needed by callback function; it was optional.
@param[in] Function Continue function called by Debug Communication library;
it was optional.
@return The debug port handle created by Debug Communication Library if Function
is not NULL.
**/
DEBUG_PORT_HANDLE
EFIAPI
DebugPortInitialize (
IN VOID *Context,
IN DEBUG_PORT_CONTINUE Function
);
/**
Read data from debug device and save the datas in buffer.
Reads NumberOfBytes data bytes from a debug device into the buffer
specified by Buffer. The number of bytes actually read is returned.
If the return value is less than NumberOfBytes, then the rest operation failed.
If NumberOfBytes is zero, then return 0.
@param Handle Debug port handle.
@param Buffer Pointer to the data buffer to store the data read from the debug device.
@param NumberOfBytes Number of bytes which will be read.
@param Timeout Timeout value for reading from debug device. It unit is Microsecond.
@retval 0 Read data failed, no data is to be read.
@retval >0 Actual number of bytes read from debug device.
**/
UINTN
EFIAPI
DebugPortReadBuffer (
IN DEBUG_PORT_HANDLE Handle,
IN UINT8 *Buffer,
IN UINTN NumberOfBytes,
IN UINTN Timeout
);
/**
Write data from buffer to debug device.
Writes NumberOfBytes data bytes from Buffer to the debug device.
The number of bytes actually written to the debug device is returned.
If the return value is less than NumberOfBytes, then the write operation failed.
If NumberOfBytes is zero, then return 0.
@param Handle Debug port handle.
@param Buffer Pointer to the data buffer to be written.
@param NumberOfBytes Number of bytes to written to the debug device.
@retval 0 NumberOfBytes is 0.
@retval >0 The number of bytes written to the debug device.
If this value is less than NumberOfBytes, then the read operation failed.
**/
UINTN
EFIAPI
DebugPortWriteBuffer (
IN DEBUG_PORT_HANDLE Handle,
IN UINT8 *Buffer,
IN UINTN NumberOfBytes
);
/**
Polls a debug device to see if there is any data waiting to be read.
Polls a debug device to see if there is any data waiting to be read.
If there is data waiting to be read from the debug device, then TRUE is returned.
If there is no data waiting to be read from the debug device, then FALSE is returned.
@param Handle Debug port handle.
@retval TRUE Data is waiting to be read from the debug device.
@retval FALSE There is no data waiting to be read from the serial device.
**/
BOOLEAN
EFIAPI
DebugPortPollBuffer (
IN DEBUG_PORT_HANDLE Handle
);
#endif

42
SourceLevelDebugPkg/Include/SoftDebuggerDefinitions.h Normal file
View File

@@ -0,0 +1,42 @@
/** @file
Soft Debugger defintions. The definitions will also be used as part
of debug transfer protocol. It is only intended to be used by Debug
related module implementation.
Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __SOFT_DEBUGGER_DEFINITIONS_H__
#define __SOFT_DEBUGGER_DEFINITIONS_H__
//
// Definition for processor mode (IA16, IA32, X64, ...)
//
#define SOFT_DEBUGGER_PROCESSOR_IA16 0
#define SOFT_DEBUGGER_PROCESSOR_IA32 1
#define SOFT_DEBUGGER_PROCESSOR_X64 2
//
// Break cause defintions
//
#define SOFT_DEBUGGER_BREAK_CAUSE_UNKNOWN 0
#define SOFT_DEBUGGER_BREAK_CAUSE_HW_BREAKPOINT 1
#define SOFT_DEBUGGER_BREAK_CAUSE_STEPPING 2
#define SOFT_DEBUGGER_BREAK_CAUSE_SW_BREAKPOINT 3
#define SOFT_DEBUGGER_BREAK_CAUSE_USER_HALT 4
#define SOFT_DEBUGGER_BREAK_CAUSE_IMAGE_LOAD 5
#define SOFT_DEBUGGER_BREAK_CAUSE_IMAGE_UNLOAD 6
#define SOFT_DEBUGGER_BREAK_CAUSE_SYSTEM_RESET 7
#define SOFT_DEBUGGER_BREAK_CAUSE_EXCEPTION 8
#define SOFT_DEBUGGER_SETTING_SMM_ENTRY_BREAK 1
#endif

407
SourceLevelDebugPkg/Include/TransferProtocol.h Normal file
View File

@@ -0,0 +1,407 @@
/** @file
Transfer protocol defintions used by debug agent and host. It is only
intended to be used by Debug related module implementation.
Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __TRANSFER_PROTOCOL_H__
#define __TRANSFER_PROTOCOL_H__
#include "ProcessorContext.h"
#include "SoftDebuggerDefinitions.h"
//
// Definitions for break command.
//
#define DEBUG_STARTING_SYMBOL_BREAK (0x21) // '!'
#define DEBUG_STARTING_SYMBOL_BREAK_STRING ("!")
//
// Definition for starting symbol of a normal debug packet. Choose a non-ASCII to avoid conflict with other serial output.
//
#define DEBUG_STARTING_SYMBOL_NORMAL (0xFE)
#pragma pack(1)
//
// Definition for common header for normal debug packets (not including break command)
//
typedef struct {
UINT8 StartSymbol;
UINT8 Command;
UINT8 DataLength;
} DEBUG_COMMAND_HEADER;
//
// Structure to facilitate debug packet header parsing or construction
//
typedef struct {
UINT8 Command;
UINT8 DataLength;
} DEBUG_COMMAND_HEADER_NO_START_SYMBOL;
//
// Definition for Command field for debug packets
//
#define DEBUG_COMMAND_REQUEST (0 << 7)
#define DEBUG_COMMAND_RESPONSE (1 << 7)
#define DEBUG_COMMAND_RESET (DEBUG_COMMAND_REQUEST | 0) // 0
#define DEBUG_COMMAND_GO (DEBUG_COMMAND_REQUEST | 1) // 1
#define DEBUG_COMMAND_BREAK_CAUSE (DEBUG_COMMAND_REQUEST | 2) // 2
#define DEBUG_COMMAND_SET_HW_BREAKPOINT (DEBUG_COMMAND_REQUEST | 3) // 3
#define DEBUG_COMMAND_CLEAR_HW_BREAKPOINT (DEBUG_COMMAND_REQUEST | 4) // 4
#define DEBUG_COMMAND_SINGLE_STEPPING (DEBUG_COMMAND_REQUEST | 5) // 5
#define DEBUG_COMMAND_SET_SW_BREAKPOINT (DEBUG_COMMAND_REQUEST | 6) // 6
#define DEBUG_COMMAND_CLEAR_SW_BREAKPOINT (DEBUG_COMMAND_REQUEST | 7) // 7
#define DEBUG_COMMAND_READ_MEMORY_8 (DEBUG_COMMAND_REQUEST | 8) // 8
#define DEBUG_COMMAND_READ_MEMORY_16 (DEBUG_COMMAND_REQUEST | 9) // 9
#define DEBUG_COMMAND_READ_MEMORY_32 (DEBUG_COMMAND_REQUEST | 10) // 10
#define DEBUG_COMMAND_READ_MEMORY_64 (DEBUG_COMMAND_REQUEST | 11) // 11
#define DEBUG_COMMAND_WRITE_MEMORY_8 (DEBUG_COMMAND_REQUEST | 12) // 12
#define DEBUG_COMMAND_WRITE_MEMORY_16 (DEBUG_COMMAND_REQUEST | 13) // 13
#define DEBUG_COMMAND_WRITE_MEMORY_32 (DEBUG_COMMAND_REQUEST | 14) // 14
#define DEBUG_COMMAND_WRITE_MEMORY_64 (DEBUG_COMMAND_REQUEST | 15) // 15
#define DEBUG_COMMAND_READ_IO (DEBUG_COMMAND_REQUEST | 16) // 16
#define DEBUG_COMMAND_WRITE_IO (DEBUG_COMMAND_REQUEST | 20) // 20
#define DEBUG_COMMAND_READ_REGISTER (DEBUG_COMMAND_REQUEST | 24) // 24
#define DEBUG_COMMAND_WRITE_REGISTER (DEBUG_COMMAND_REQUEST | 26) // 26
#define DEBUG_COMMAND_STEP_OVER (DEBUG_COMMAND_REQUEST | 28) // 28
#define DEBUG_COMMAND_STEP_OUT (DEBUG_COMMAND_REQUEST | 29) // 29
#define DEBUG_COMMAND_STEP_BRANCH (DEBUG_COMMAND_REQUEST | 30) // 30
#define DEBUG_COMMAND_ARCH_MODE (DEBUG_COMMAND_REQUEST | 34) // 34
#define DEBUG_COMMAND_READ_MSR (DEBUG_COMMAND_REQUEST | 35) // 35
#define DEBUG_COMMAND_WRITE_MSR (DEBUG_COMMAND_REQUEST | 36) // 36
#define DEBUG_COMMAND_READ_REGISTER_GROUP (DEBUG_COMMAND_REQUEST | 37) // 37
#define DEBUG_COMMAND_SET_DEBUG_FLAG (DEBUG_COMMAND_REQUEST | 38) // 38
#define DEBUG_COMMAND_GET_REVISION (DEBUG_COMMAND_REQUEST | 39) // 30
#define DEBUG_COMMAND_GET_EXCEPTION (DEBUG_COMMAND_REQUEST | 40) // 40
#define DEBUG_COMMAND_SET_VIEWPOINT (DEBUG_COMMAND_REQUEST | 41) // 41
#define DEBUG_COMMAND_GET_VIEWPOINT (DEBUG_COMMAND_REQUEST | 42) // 42
//
// The below are target side initiated commands.
//
#define DEBUG_COMMAND_INIT_BREAK (DEBUG_COMMAND_REQUEST | 63) // 63
#define DEBUG_COMMAND_BREAK_POINT (DEBUG_COMMAND_REQUEST | 62) // 62
#define DEBUG_COMMAND_MEMORY_READY (DEBUG_COMMAND_REQUEST | 61) // 61
#define DEBUG_COMMAND_OK (DEBUG_COMMAND_RESPONSE | 0)
#define DEBUG_COMMAND_RESEND (DEBUG_COMMAND_RESPONSE | 1)
#define DEBUG_COMMAND_ABORT (DEBUG_COMMAND_RESPONSE | 2)
//
// The below 2 commands are used when transferring big data (like > ~250 bytes). The sequence is:
// Host Macine Target Macine
// Request =>
// <= IN_PROGRESS with part of the data
// CONTINUE =>
// (could have multiple IN_PROGRESS and CONTINUE interactions)
// <= OK with the last part of data
// OK (no data as ACK) =>
//
#define DEBUG_COMMAND_IN_PROGRESS (DEBUG_COMMAND_RESPONSE | 3) // Used when trying to
#define DEBUG_COMMAND_CONTINUE (DEBUG_COMMAND_RESPONSE | 4) // Used when trying to transfer big data (like > ~250 bytes)
//
// The below 2 commands are used to support deferred halt. HALT_DEFERRED will be returned when a halt request received while target is already in inter-active mode.
// HALT_PROCESSED will be return as a possible return value for GO command, if target has a pending halt request.
//
#define DEBUG_COMMAND_HALT_DEFERRED (DEBUG_COMMAND_RESPONSE | 5)
#define DEBUG_COMMAND_HALT_PROCESSED (DEBUG_COMMAND_RESPONSE | 6)
#define DEBUG_COMMAND_NOT_SUPPORTED (DEBUG_COMMAND_RESPONSE | 15)
//
// Definition for data field for debug packets
//
#define DEBUG_DATA_MAXIMUM_LENGTH_FOR_SMALL_COMMANDS 20
#define DEBUG_DATA_UPPER_LIMIT 0xff // This is the upper limit for the data size, by the limit of the packet header definition.
#define DEBUG_DATA_MAXIMUM_REAL_DATA 0xf8
#define DEBUG_DEFINITION_MAX_IO_LENGTH 4
//
// Response data for DEBUG_COMMAND_BREAK_CAUSE
//
typedef struct {
UINT8 Cause;
UINT64 StopAddress;
} DEBUG_DATA_RESPONSE_BREAK_CAUSE;
//
// Break type defintions for DEBUG_DATA_BREAK_CAUSE
//
#define DEBUG_DATA_BREAK_CAUSE_UNKNOWN 0
#define DEBUG_DATA_BREAK_CAUSE_HW_BREAKPOINT 1
#define DEBUG_DATA_BREAK_CAUSE_STEPPING 2
#define DEBUG_DATA_BREAK_CAUSE_SW_BREAKPOINT 3
#define DEBUG_DATA_BREAK_CAUSE_USER_HALT 4
#define DEBUG_DATA_BREAK_CAUSE_IMAGE_LOAD 5
#define DEBUG_DATA_BREAK_CAUSE_IMAGE_UNLOAD 6
#define DEBUG_DATA_BREAK_CAUSE_SYSTEM_RESET 7
#define DEBUG_DATA_BREAK_CAUSE_EXCEPTION 8
#define DEBUG_DATA_BREAK_CAUSE_MEMORY_READY 9
//
// Response data for DEBUG_COMMAND_ARCH_MODE, defined as SOFT_DEBUGGER_PROCESSOR_...
//
typedef struct {
UINT8 CpuMode;
} DEBUG_DATA_RESPONSE_ARCH_MODE;
//
// Cpu architecture defintions for DEBUG_DATA_RESPONSE_ARCH_MODE
//
#define DEBUG_DATA_BREAK_CPU_ARCH_IA16 0
#define DEBUG_DATA_BREAK_CPU_ARCH_IA32 1
#define DEBUG_DATA_BREAK_CPU_ARCH_X64 2
//
// Command and response data for DEBUG_COMMAND_XX_YY_BREAKPOINT
//
typedef struct {
UINT8 Length:2; // Refer to below DEBUG_DATA_BREAKPOINT_LENGTH_XX macros
UINT8 Access:2; // Refer to below DEBUG_DATA_BREAKPOINT_ACCESS_XX macros
UINT8 Index:2; // Index of debug register
UINT8 Reserved:2;
} DEBUG_DATA_BREAKPOINT_TYPE;
#define DEBUG_DATA_BREAKPOINT_MEMORY_ACCESS (0x11)
#define DEBUG_DATA_BREAKPOINT_IO_ACCESS (0x10)
#define DEBUG_DATA_BREAKPOINT_MEMORY_WRITE (0x01)
#define DEBUG_DATA_BREAKPOINT_MEMORY_EXECUTE (0x00)
#define DEBUG_DATA_BREAKPOINT_LENGTH_64 (0x11)
#define DEBUG_DATA_BREAKPOINT_LENGTH_32 (0x10)
#define DEBUG_DATA_BREAKPOINT_LENGTH_16 (0x01)
#define DEBUG_DATA_BREAKPOINT_LENGTH_8 (0x00)
//
// Command data for DEBUG_COMMAND_SET_HW_BREAKPOINT
//
typedef struct {
DEBUG_DATA_BREAKPOINT_TYPE Type;
UINT64 Address;
} DEBUG_DATA_SET_HW_BREAKPOINT;
//
// Command data for DEBUG_COMMAND_CLEAR_HW_BREAKPOINT
//
typedef struct {
UINT8 IndexMask; // 0x0f will clear all hw breakpoints
} DEBUG_DATA_CLEAR_HW_BREAKPOINT;
//
// Command data for DEBUG_COMMAND_SET_SW_BREAKPOINT
//
typedef struct {
UINT64 Address;
} DEBUG_DATA_SET_SW_BREAKPOINT;
//
// Response data for DEBUG_COMMAND_SET_SW_BREAKPOINT
//
typedef struct {
UINT8 OriginalData;
} DEBUG_DATA_RESPONSE_SET_SW_BREAKPOINT;
//
// Command data for DEBUG_COMMAND_CLEAR_SW_BREAKPOINT
//
typedef DEBUG_DATA_SET_SW_BREAKPOINT DEBUG_DATA_CLEAR_SW_BREAKPOINT;
//
// Command data for DEBUG_COMMAND_READ_MEMORY_XX
//
typedef struct {
UINT64 Address;
UINT16 Count;
} DEBUG_DATA_READ_MEMORY_8;
typedef DEBUG_DATA_READ_MEMORY_8 DEBUG_DATA_READ_MEMORY_16;
typedef DEBUG_DATA_READ_MEMORY_8 DEBUG_DATA_READ_MEMORY_32;
typedef DEBUG_DATA_READ_MEMORY_8 DEBUG_DATA_READ_MEMORY_64;
//
// Command data for DEBUG_COMMAND_WRITE_MEMORY_XX
//
typedef struct {
UINT64 Address;
UINT16 Count;
UINT8 Data; // The actual length for this field is decided by Width x Count
} DEBUG_DATA_WRITE_MEMORY_8;
typedef DEBUG_DATA_WRITE_MEMORY_8 DEBUG_DATA_WRITE_MEMORY_16;
typedef DEBUG_DATA_WRITE_MEMORY_8 DEBUG_DATA_WRITE_MEMORY_32;
typedef DEBUG_DATA_WRITE_MEMORY_8 DEBUG_DATA_WRITE_MEMORY_64;
//
// Command data for DEBUG_COMMAND_READ_IO
//
typedef struct {
UINT16 Port;
UINT8 Width;
} DEBUG_DATA_READ_IO;
//
// Response data for DEBUG_COMMAND_READ_IO
//
typedef struct {
UINT8 Data; // The actual length of this structure will be adjusted according to the Width field
} DEBUG_DATA_RESPONSE_READ_IO;
//
// Command data for DEBUG_COMMAND_WRITE_IO
//
typedef struct {
UINT16 Port;
UINT8 Width;
UINT8 Data; // The actual length of this structure will be adjusted according to the Width field
} DEBUG_DATA_WRITE_IO;
//
// Command data for DEBUG_COMMAND_READ_REGISTER
//
typedef struct {
UINT8 Index; // defined as DEBUG_DEFINITION_REGISTER_XX
UINT8 Offset:4;
UINT8 Length:4;
} DEBUG_DATA_READ_REGISTER;
//
// Command data for DEBUG_COMMAND_WRITE_REGISTER
//
typedef struct {
UINT8 Index; // defined as DEBUG_DEFINITION_REGISTER_XX
UINT8 Offset:4;
UINT8 Length:4;
UINT64 Value;
} DEBUG_DATA_WRITE_REGISTER;
//
// Command data for DEBUG_COMMAND_READ_MSR
//
typedef struct {
UINT32 Index;
} DEBUG_DATA_READ_MSR;
//
// Response data for DEBUG_COMMAND_READ_MSR
//
typedef struct {
UINT64 Value;
} DEBUG_DATA_RESPONSE_READ_MSR;
//
// Command data for DEBUG_COMMAND_WRITE_MSR
//
typedef struct {
UINT32 Index;
UINT64 Value;
} DEBUG_DATA_WRITE_MSR;
//
// Command data for DEBUG_COMMAND_READ_REGISTER_GROUP
//
typedef struct {
// For possible values, refer to the definition for DEBUG_DEFINITION_REGISTER_GROUP_XXX (in another .h file as it is architecture specific)
UINT8 Index;
} DEBUG_DATA_READ_REGISTER_GROUP;
//
// Response data for DEBUG_COMMAND_GET_REVISION
//
typedef struct {
UINT32 Revision;
UINT32 Capabilities;
} DEBUG_DATA_RESPONSE_GET_REVISION;
//
// Response data for DEBUG_COMMAND_GET_EXCEPTION
//
typedef struct {
UINT8 ExceptionNum;
UINT64 ExceptionData;
} DEBUG_DATA_RESPONSE_GET_EXCEPTION;
typedef struct {
UINT8 DRn; // The index of DR register which to be used as temporary breakpoint
} DEBUG_DATA_STEP_OVER;
//
// Command data for DEBUG_COMMAND_SET_DEBUG_FLAG
//
typedef struct {
UINT32 DebugFlag; // The index of DR register which to be used as temporary breakpoint
} DEBUG_DATA_SET_DEBUG_FLAG;
//
// Command data for DEBUG_COMMAND_SET_VIEWPOINT
// If viewpoint is changed successfully, DEBUG_COMMAND_OK will be returned.
// If viewpoint is not availabe, DEBUG_COMMAND_NOT_SUPPORTED will be returned.
//
typedef struct {
UINT32 ViewPoint; // The index of viewpoint will be set
} DEBUG_DATA_SET_VIEWPOINT;
//
// Response data for DEBUG_COMMAND_GET_VIEWPOINT
//
typedef struct {
UINT32 ViewPoint; // The index of viewpoint will be returned
} DEBUG_DATA_RESPONSE_GET_VIEWPOINT;
#pragma pack()
#define DEBUG_PACKET_CONSTRUCTOR_WITH_NO_DATA(DebugPacket,ShortCommandType) \
((DEBUG_COMMAND_HEADER *)DebugPacket)->StartSymbol = DEBUG_STARTING_SYMBOL_NORMAL; \
((DEBUG_COMMAND_HEADER *)DebugPacket)->Command = DEBUG_COMMAND_##ShortCommandType; \
((DEBUG_COMMAND_HEADER *)DebugPacket)->DataLength = 0;
#define DEBUG_PACKET_CONSTRUCTOR_WITH_DATA(DebugPacket,ShortCommandType, DebugPacketDataPointer, PacketLength) \
((DEBUG_COMMAND_HEADER *)DebugPacket)->StartSymbol = DEBUG_STARTING_SYMBOL_NORMAL; \
((DEBUG_COMMAND_HEADER *)DebugPacket)->Command = DEBUG_COMMAND_##ShortCommandType; \
((DEBUG_COMMAND_HEADER *)DebugPacket)->DataLength = sizeof (DEBUG_DATA_##ShortCommandType); \
*DebugPacketDataPointer = (DEBUG_DATA_##ShortCommandType *)((DEBUG_COMMAND_HEADER *)DebugPacket+1); \
*PacketLength = sizeof (DEBUG_COMMAND_HEADER) + sizeof (DEBUG_DATA_##ShortCommandType);
#endif