12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355 |
- /* Debug stub for Z80.
- Copyright (C) 2021-2022 Free Software Foundation, Inc.
- This file is part of GDB.
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- (at your option) any later version.
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
- /* Usage:
- 1. Copy this file to project directory
- 2. Configure it commenting/uncommenting macros below or define DBG_CONFIGURED
- and all required macros and then include this file to one of your C-source
- files.
- 3. Implement getDebugChar() and putDebugChar(), functions must not return
- until data received or sent.
- 4. Implement all optional functions used to toggle breakpoints/watchpoints,
- if supported. Do not write fuctions to toggle software breakpoints if
- you unsure (GDB will do itself).
- 5. Implement serial port initialization routine called at program start.
- 6. Add necessary debugger entry points to your program, for example:
- .org 0x08 ;RST 8 handler
- jp _debug_swbreak
- ...
- .org 0x66 ;NMI handler
- jp _debug_nmi
- ...
- main_loop:
- halt
- call isDbgInterrupt
- jr z,101$
- ld hl, 2 ;EX_SIGINT
- push hl
- call _debug_exception
- 101$:
- ...
- 7. Compile file using SDCC (supported ports are: z80, z180, z80n, gbz80 and
- ez80_z80), do not use --peep-asm option. For example:
- $ sdcc -mz80 --opt-code-size --max-allocs-per-node 50000 z80-stub.c
- */
- /******************************************************************************\
- Configuration
- \******************************************************************************/
- #ifndef DBG_CONFIGURED
- /* Uncomment this line, if stub size is critical for you */
- //#define DBG_MIN_SIZE
- /* Comment this line out if software breakpoints are unsupported.
- If you have special function to toggle software breakpoints, then provide
- here name of these function. Expected prototype:
- int toggle_swbreak(int set, void *addr);
- function must return 0 on success. */
- //#define DBG_SWBREAK toggle_swbreak
- #define DBG_SWBREAK
- /* Define if one of standard RST handlers is used as software
- breakpoint entry point */
- //#define DBG_SWBREAK_RST 0x08
- /* if platform supports hardware breakpoints then define following macro
- by name of function. Fuction must have next prototype:
- int toggle_hwbreak(int set, void *addr);
- function must return 0 on success. */
- //#define DBG_HWBREAK toggle_hwbreak
- /* if platform supports hardware watchpoints then define all or some of
- following macros by names of functions. Fuctions prototypes:
- int toggle_watch(int set, void *addr, size_t size); // memory write watch
- int toggle_rwatch(int set, void *addr, size_t size); // memory read watch
- int toggle_awatch(int set, void *addr, size_t size); // memory access watch
- function must return 0 on success. */
- //#define DBG_WWATCH toggle_watch
- //#define DBG_RWATCH toggle_rwatch
- //#define DBG_AWATCH toggle_awatch
- /* Size of hardware breakpoint. Required to correct PC. */
- #define DBG_HWBREAK_SIZE 0
- /* Define following macro if you need custom memory read/write routine.
- Function should return non-zero on success, and zero on failure
- (for example, write to ROM area).
- Useful with overlays (bank switching).
- Do not forget to define:
- _ovly_table - overlay table
- _novlys - number of items in _ovly_table
- or
- _ovly_region_table - overlay regions table
- _novly_regions - number of items in _ovly_region_table
- _ovly_debug_prepare - function is called before overlay mapping
- _ovly_debug_event - function is called after overlay mapping
- */
- //#define DBG_MEMCPY memcpy
- /* define dedicated stack size if required */
- //#define DBG_STACK_SIZE 256
- /* max GDB packet size
- should be much less that DBG_STACK_SIZE because it will be allocated on stack
- */
- #define DBG_PACKET_SIZE 150
- /* Uncomment if required to use trampoline when resuming operation.
- Useful with dedicated stack when stack pointer do not point to the stack or
- stack is not writable */
- //#define DBG_USE_TRAMPOLINE
- /* Uncomment following macro to enable debug printing to debugger console */
- //#define DBG_PRINT
- #define DBG_NMI_EX EX_HWBREAK
- #define DBG_INT_EX EX_SIGINT
- /* Define following macro to statement, which will be exectuted after entering to
- stub_main function. Statement should include semicolon. */
- //#define DBG_ENTER debug_enter();
- /* Define following macro to instruction(s), which will be execute before return
- control to the program. It is useful when gdb-stub is placed in one of overlays.
- This procedure must not change any register. On top of stack before invocation
- will be return address of the program. */
- //#define DBG_RESUME jp _restore_bank
- /* Define following macro to the string containing memory map definition XML.
- GDB will use it to select proper breakpoint type (HW or SW). */
- /*#define DBG_MEMORY_MAP "\
- <memory-map>\
- <memory type=\"rom\" start=\"0x0000\" length=\"0x4000\"/>\
- <!-- <memory type=\"flash\" start=\"0x4000\" length=\"0x4000\">\
- <property name=\"blocksize\">128</property>\
- </memory> -->\
- <memory type=\"ram\" start=\"0x8000\" length=\"0x8000\"/>\
- </memory-map>\
- "
- */
- #endif /* DBG_CONFIGURED */
- /******************************************************************************\
- Public Interface
- \******************************************************************************/
- /* Enter to debug mode from software or hardware breakpoint.
- Assume address of next instruction after breakpoint call is on top of stack.
- Do JP _debug_swbreak or JP _debug_hwbreak from RST handler, for example.
- */
- void debug_swbreak (void);
- void debug_hwbreak (void);
- /* Jump to this function from NMI handler. Just replace RETN instruction by
- JP _debug_nmi
- Use if NMI detects request to enter to debug mode.
- */
- void debug_nmi (void);
- /* Jump to this function from INT handler. Just replace EI+RETI instructions by
- JP _debug_int
- Use if INT detects request to enter to debug mode.
- */
- void debug_int (void);
- #define EX_SWBREAK 0 /* sw breakpoint */
- #define EX_HWBREAK -1 /* hw breakpoint */
- #define EX_WWATCH -2 /* memory write watch */
- #define EX_RWATCH -3 /* memory read watch */
- #define EX_AWATCH -4 /* memory access watch */
- #define EX_SIGINT 2
- #define EX_SIGTRAP 5
- #define EX_SIGABRT 6
- #define EX_SIGBUS 10
- #define EX_SIGSEGV 11
- /* or any standard *nix signal value */
- /* Enter to debug mode (after receiving BREAK from GDB, for example)
- * Assume:
- * program PC in (SP+0)
- * caught signal in (SP+2)
- * program SP is SP+4
- */
- void debug_exception (int ex);
- /* Prints to debugger console. */
- void debug_print(const char *str);
- /******************************************************************************\
- Required functions
- \******************************************************************************/
- extern int getDebugChar (void);
- extern void putDebugChar (int ch);
- #ifdef DBG_SWBREAK
- #define DO_EXPAND(VAL) VAL ## 123456
- #define EXPAND(VAL) DO_EXPAND(VAL)
- #if EXPAND(DBG_SWBREAK) != 123456
- #define DBG_SWBREAK_PROC DBG_SWBREAK
- extern int DBG_SWBREAK(int set, void *addr);
- #endif
- #undef EXPAND
- #undef DO_EXPAND
- #endif /* DBG_SWBREAK */
- #ifdef DBG_HWBREAK
- extern int DBG_HWBREAK(int set, void *addr);
- #endif
- #ifdef DBG_MEMCPY
- extern void* DBG_MEMCPY (void *dest, const void *src, unsigned n);
- #endif
- #ifdef DBG_WWATCH
- extern int DBG_WWATCH(int set, void *addr, unsigned size);
- #endif
- #ifdef DBG_RWATCH
- extern int DBG_RWATCH(int set, void *addr, unsigned size);
- #endif
- #ifdef DBG_AWATCH
- extern int DBG_AWATCH(int set, void *addr, unsigned size);
- #endif
- /******************************************************************************\
- IMPLEMENTATION
- \******************************************************************************/
- #include <string.h>
- #ifndef NULL
- # define NULL (void*)0
- #endif
- typedef unsigned char byte;
- typedef unsigned short word;
- /* CPU state */
- #ifdef __SDCC_ez80_adl
- # define REG_SIZE 3
- #else
- # define REG_SIZE 2
- #endif /* __SDCC_ez80_adl */
- #define R_AF (0*REG_SIZE)
- #define R_BC (1*REG_SIZE)
- #define R_DE (2*REG_SIZE)
- #define R_HL (3*REG_SIZE)
- #define R_SP (4*REG_SIZE)
- #define R_PC (5*REG_SIZE)
- #ifndef __SDCC_gbz80
- #define R_IX (6*REG_SIZE)
- #define R_IY (7*REG_SIZE)
- #define R_AF_ (8*REG_SIZE)
- #define R_BC_ (9*REG_SIZE)
- #define R_DE_ (10*REG_SIZE)
- #define R_HL_ (11*REG_SIZE)
- #define R_IR (12*REG_SIZE)
- #ifdef __SDCC_ez80_adl
- #define R_SPS (13*REG_SIZE)
- #define NUMREGBYTES (14*REG_SIZE)
- #else
- #define NUMREGBYTES (13*REG_SIZE)
- #endif /* __SDCC_ez80_adl */
- #else
- #define NUMREGBYTES (6*REG_SIZE)
- #define FASTCALL
- #endif /*__SDCC_gbz80 */
- static byte state[NUMREGBYTES];
- #if DBG_PACKET_SIZE < (NUMREGBYTES*2+5)
- #error "Too small DBG_PACKET_SIZE"
- #endif
- #ifndef FASTCALL
- #define FASTCALL __z88dk_fastcall
- #endif
- /* dedicated stack */
- #ifdef DBG_STACK_SIZE
- #define LOAD_SP ld sp, #_stack + DBG_STACK_SIZE
- static char stack[DBG_STACK_SIZE];
- #else
- #undef DBG_USE_TRAMPOLINE
- #define LOAD_SP
- #endif
- #ifndef DBG_ENTER
- #define DBG_ENTER
- #endif
- #ifndef DBG_RESUME
- #define DBG_RESUME ret
- #endif
- static signed char sigval;
- static void stub_main (int sigval, int pc_adj);
- static char high_hex (byte v) FASTCALL;
- static char low_hex (byte v) FASTCALL;
- static char put_packet_info (const char *buffer) FASTCALL;
- static void save_cpu_state (void);
- static void rest_cpu_state (void);
- /******************************************************************************/
- #ifdef DBG_SWBREAK
- #ifdef DBG_SWBREAK_RST
- #define DBG_SWBREAK_SIZE 1
- #else
- #define DBG_SWBREAK_SIZE 3
- #endif
- void
- debug_swbreak (void) __naked
- {
- __asm
- ld (#_state + R_SP), sp
- LOAD_SP
- call _save_cpu_state
- ld hl, #-DBG_SWBREAK_SIZE
- push hl
- ld hl, #EX_SWBREAK
- push hl
- call _stub_main
- .globl _break_handler
- #ifdef DBG_SWBREAK_RST
- _break_handler = DBG_SWBREAK_RST
- #else
- _break_handler = _debug_swbreak
- #endif
- __endasm;
- }
- #endif /* DBG_SWBREAK */
- /******************************************************************************/
- #ifdef DBG_HWBREAK
- #ifndef DBG_HWBREAK_SIZE
- #define DBG_HWBREAK_SIZE 0
- #endif /* DBG_HWBREAK_SIZE */
- void
- debug_hwbreak (void) __naked
- {
- __asm
- ld (#_state + R_SP), sp
- LOAD_SP
- call _save_cpu_state
- ld hl, #-DBG_HWBREAK_SIZE
- push hl
- ld hl, #EX_HWBREAK
- push hl
- call _stub_main
- __endasm;
- }
- #endif /* DBG_HWBREAK_SET */
- /******************************************************************************/
- void
- debug_exception (int ex) __naked
- {
- __asm
- ld (#_state + R_SP), sp
- LOAD_SP
- call _save_cpu_state
- ld hl, #0
- push hl
- #ifdef __SDCC_gbz80
- ld hl, #_state + R_SP
- ld a, (hl+)
- ld h, (hl)
- ld l, a
- #else
- ld hl, (#_state + R_SP)
- #endif
- inc hl
- inc hl
- ld e, (hl)
- inc hl
- ld d, (hl)
- push de
- call _stub_main
- __endasm;
- (void)ex;
- }
- /******************************************************************************/
- #ifndef __SDCC_gbz80
- void
- debug_nmi(void) __naked
- {
- __asm
- ld (#_state + R_SP), sp
- LOAD_SP
- call _save_cpu_state
- ld hl, #0 ;pc_adj
- push hl
- ld hl, #DBG_NMI_EX
- push hl
- ld hl, #_stub_main
- push hl
- push hl
- retn
- __endasm;
- }
- #endif
- /******************************************************************************/
- void
- debug_int(void) __naked
- {
- __asm
- ld (#_state + R_SP), sp
- LOAD_SP
- call _save_cpu_state
- ld hl, #0 ;pc_adj
- push hl
- ld hl, #DBG_INT_EX
- push hl
- ld hl, #_stub_main
- push hl
- push hl
- ei
- reti
- __endasm;
- }
- /******************************************************************************/
- #ifdef DBG_PRINT
- void
- debug_print(const char *str)
- {
- putDebugChar ('$');
- putDebugChar ('O');
- char csum = 'O';
- for (; *str != '\0'; )
- {
- char c = high_hex (*str);
- csum += c;
- putDebugChar (c);
- c = low_hex (*str++);
- csum += c;
- putDebugChar (c);
- }
- putDebugChar ('#');
- putDebugChar (high_hex (csum));
- putDebugChar (low_hex (csum));
- }
- #endif /* DBG_PRINT */
- /******************************************************************************/
- static void store_pc_sp (int pc_adj) FASTCALL;
- #define get_reg_value(mem) (*(void* const*)(mem))
- #define set_reg_value(mem,val) do { (*(void**)(mem) = (val)); } while (0)
- static char* byte2hex(char *buf, byte val);
- static int hex2int (const char **buf) FASTCALL;
- static char* int2hex (char *buf, int v);
- static void get_packet (char *buffer);
- static void put_packet (const char *buffer);
- static char process (char *buffer) FASTCALL;
- static void rest_cpu_state (void);
- static void
- stub_main (int ex, int pc_adj)
- {
- char buffer[DBG_PACKET_SIZE+1];
- sigval = (signed char)ex;
- store_pc_sp (pc_adj);
- DBG_ENTER
- /* after starting gdb_stub must always return stop reason */
- *buffer = '?';
- for (; process (buffer);)
- {
- put_packet (buffer);
- get_packet (buffer);
- }
- put_packet (buffer);
- rest_cpu_state ();
- }
- static void
- get_packet (char *buffer)
- {
- byte csum;
- char ch;
- char *p;
- byte esc;
- #if DBG_PACKET_SIZE <= 256
- byte count; /* it is OK to use up to 256 here */
- #else
- unsigned count;
- #endif
- for (;; putDebugChar ('-'))
- {
- /* wait for packet start character */
- while (getDebugChar () != '$');
- retry:
- csum = 0;
- esc = 0;
- p = buffer;
- count = DBG_PACKET_SIZE;
- do
- {
- ch = getDebugChar ();
- switch (ch)
- {
- case '$':
- goto retry;
- case '#':
- goto finish;
- case '}':
- esc = 0x20;
- break;
- default:
- *p++ = ch ^ esc;
- esc = 0;
- --count;
- }
- csum += ch;
- }
- while (count != 0);
- finish:
- *p = '\0';
- if (ch != '#') /* packet is too large */
- continue;
- ch = getDebugChar ();
- if (ch != high_hex (csum))
- continue;
- ch = getDebugChar ();
- if (ch != low_hex (csum))
- continue;
- break;
- }
- putDebugChar ('+');
- }
- static void
- put_packet (const char *buffer)
- {
- /* $<packet info>#<checksum>. */
- for (;;)
- {
- putDebugChar ('$');
- char checksum = put_packet_info (buffer);
- putDebugChar ('#');
- putDebugChar (high_hex(checksum));
- putDebugChar (low_hex(checksum));
- for (;;)
- {
- char c = getDebugChar ();
- switch (c)
- {
- case '+': return;
- case '-': break;
- default:
- putDebugChar (c);
- continue;
- }
- break;
- }
- }
- }
- static char
- put_packet_info (const char *src) FASTCALL
- {
- char ch;
- char checksum = 0;
- for (;;)
- {
- ch = *src++;
- if (ch == '\0')
- break;
- if (ch == '}' || ch == '*' || ch == '#' || ch == '$')
- {
- /* escape special characters */
- putDebugChar ('}');
- checksum += '}';
- ch ^= 0x20;
- }
- putDebugChar (ch);
- checksum += ch;
- }
- return checksum;
- }
- static void
- store_pc_sp (int pc_adj) FASTCALL
- {
- byte *sp = get_reg_value (&state[R_SP]);
- byte *pc = get_reg_value (sp);
- pc += pc_adj;
- set_reg_value (&state[R_PC], pc);
- set_reg_value (&state[R_SP], sp + REG_SIZE);
- }
- static char *mem2hex (char *buf, const byte *mem, unsigned bytes);
- static char *hex2mem (byte *mem, const char *buf, unsigned bytes);
- /* Command processors. Takes pointer to buffer (begins from command symbol),
- modifies buffer, returns: -1 - empty response (ignore), 0 - success,
- positive: error code. */
- #ifdef DBG_MIN_SIZE
- static signed char
- process_question (char *p) FASTCALL
- {
- signed char sig;
- *p++ = 'S';
- sig = sigval;
- if (sig <= 0)
- sig = EX_SIGTRAP;
- p = byte2hex (p, (byte)sig);
- *p = '\0';
- return 0;
- }
- #else /* DBG_MIN_SIZE */
- static char *format_reg_value (char *p, unsigned reg_num, const byte *value);
- static signed char
- process_question (char *p) FASTCALL
- {
- signed char sig;
- *p++ = 'T';
- sig = sigval;
- if (sig <= 0)
- sig = EX_SIGTRAP;
- p = byte2hex (p, (byte)sig);
- p = format_reg_value(p, R_AF/REG_SIZE, &state[R_AF]);
- p = format_reg_value(p, R_SP/REG_SIZE, &state[R_SP]);
- p = format_reg_value(p, R_PC/REG_SIZE, &state[R_PC]);
- #if defined(DBG_SWBREAK_PROC) || defined(DBG_HWBREAK) || defined(DBG_WWATCH) || defined(DBG_RWATCH) || defined(DBG_AWATCH)
- const char *reason;
- unsigned addr = 0;
- switch (sigval)
- {
- #ifdef DBG_SWBREAK_PROC
- case EX_SWBREAK:
- reason = "swbreak";
- break;
- #endif
- #ifdef DBG_HWBREAK
- case EX_HWBREAK:
- reason = "hwbreak";
- break;
- #endif
- #ifdef DBG_WWATCH
- case EX_WWATCH:
- reason = "watch";
- addr = 1;
- break;
- #endif
- #ifdef DBG_RWATCH
- case EX_RWATCH:
- reason = "rwatch";
- addr = 1;
- break;
- #endif
- #ifdef DBG_AWATCH
- case EX_AWATCH:
- reason = "awatch";
- addr = 1;
- break;
- #endif
- default:
- goto finish;
- }
- while ((*p++ = *reason++))
- ;
- --p;
- *p++ = ':';
- if (addr != 0)
- p = int2hex(p, addr);
- *p++ = ';';
- finish:
- #endif /* DBG_HWBREAK, DBG_WWATCH, DBG_RWATCH, DBG_AWATCH */
- *p++ = '\0';
- return 0;
- }
- #endif /* DBG_MINSIZE */
- #define STRING2(x) #x
- #define STRING1(x) STRING2(x)
- #define STRING(x) STRING1(x)
- #ifdef DBG_MEMORY_MAP
- static void read_memory_map (char *buffer, unsigned offset, unsigned length);
- #endif
- static signed char
- process_q (char *buffer) FASTCALL
- {
- char *p;
- if (memcmp (buffer + 1, "Supported", 9) == 0)
- {
- memcpy (buffer, "PacketSize=", 11);
- p = int2hex (&buffer[11], DBG_PACKET_SIZE);
- #ifndef DBG_MIN_SIZE
- #ifdef DBG_SWBREAK_PROC
- memcpy (p, ";swbreak+", 9);
- p += 9;
- #endif
- #ifdef DBG_HWBREAK
- memcpy (p, ";hwbreak+", 9);
- p += 9;
- #endif
- #endif /* DBG_MIN_SIZE */
- #ifdef DBG_MEMORY_MAP
- memcpy (p, ";qXfer:memory-map:read+", 23);
- p += 23;
- #endif
- *p = '\0';
- return 0;
- }
- #ifdef DBG_MEMORY_MAP
- if (memcmp (buffer + 1, "Xfer:memory-map:read:", 21) == 0)
- {
- p = strchr (buffer + 1 + 21, ':');
- if (p == NULL)
- return 1;
- ++p;
- unsigned offset = hex2int (&p);
- if (*p++ != ',')
- return 2;
- unsigned length = hex2int (&p);
- if (length == 0)
- return 3;
- if (length > DBG_PACKET_SIZE)
- return 4;
- read_memory_map (buffer, offset, length);
- return 0;
- }
- #endif
- #ifndef DBG_MIN_SIZE
- if (memcmp (&buffer[1], "Attached", 9) == 0)
- {
- /* Just report that GDB attached to existing process
- if it is not applicable for you, then send patches */
- memcpy(buffer, "1", 2);
- return 0;
- }
- #endif /* DBG_MIN_SIZE */
- *buffer = '\0';
- return -1;
- }
- static signed char
- process_g (char *buffer) FASTCALL
- {
- mem2hex (buffer, state, NUMREGBYTES);
- return 0;
- }
- static signed char
- process_G (char *buffer) FASTCALL
- {
- hex2mem (state, &buffer[1], NUMREGBYTES);
- /* OK response */
- *buffer = '\0';
- return 0;
- }
- static signed char
- process_m (char *buffer) FASTCALL
- {/* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
- char *p = &buffer[1];
- byte *addr = (void*)hex2int(&p);
- if (*p++ != ',')
- return 1;
- unsigned len = (unsigned)hex2int(&p);
- if (len == 0)
- return 2;
- if (len > DBG_PACKET_SIZE/2)
- return 3;
- p = buffer;
- #ifdef DBG_MEMCPY
- do
- {
- byte tmp[16];
- unsigned tlen = sizeof(tmp);
- if (tlen > len)
- tlen = len;
- if (!DBG_MEMCPY(tmp, addr, tlen))
- return 4;
- p = mem2hex (p, tmp, tlen);
- addr += tlen;
- len -= tlen;
- }
- while (len);
- #else
- p = mem2hex (p, addr, len);
- #endif
- return 0;
- }
- static signed char
- process_M (char *buffer) FASTCALL
- {/* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
- char *p = &buffer[1];
- byte *addr = (void*)hex2int(&p);
- if (*p != ',')
- return 1;
- ++p;
- unsigned len = (unsigned)hex2int(&p);
- if (*p++ != ':')
- return 2;
- if (len == 0)
- goto end;
- if (len*2 + (p - buffer) > DBG_PACKET_SIZE)
- return 3;
- #ifdef DBG_MEMCPY
- do
- {
- byte tmp[16];
- unsigned tlen = sizeof(tmp);
- if (tlen > len)
- tlen = len;
- p = hex2mem (tmp, p, tlen);
- if (!DBG_MEMCPY(addr, tmp, tlen))
- return 4;
- addr += tlen;
- len -= tlen;
- }
- while (len);
- #else
- hex2mem (addr, p, len);
- #endif
- end:
- /* OK response */
- *buffer = '\0';
- return 0;
- }
- #ifndef DBG_MIN_SIZE
- static signed char
- process_X (char *buffer) FASTCALL
- {/* XAA..AA,LLLL: Write LLLL binary bytes at address AA.AA return OK */
- char *p = &buffer[1];
- byte *addr = (void*)hex2int(&p);
- if (*p != ',')
- return 1;
- ++p;
- unsigned len = (unsigned)hex2int(&p);
- if (*p++ != ':')
- return 2;
- if (len == 0)
- goto end;
- if (len + (p - buffer) > DBG_PACKET_SIZE)
- return 3;
- #ifdef DBG_MEMCPY
- if (!DBG_MEMCPY(addr, p, len))
- return 4;
- #else
- memcpy (addr, p, len);
- #endif
- end:
- /* OK response */
- *buffer = '\0';
- return 0;
- }
- #else /* DBG_MIN_SIZE */
- static signed char
- process_X (char *buffer) FASTCALL
- {
- (void)buffer;
- return -1;
- }
- #endif /* DBG_MIN_SIZE */
- static signed char
- process_c (char *buffer) FASTCALL
- {/* 'cAAAA' - Continue at address AAAA(optional) */
- const char *p = &buffer[1];
- if (*p != '\0')
- {
- void *addr = (void*)hex2int(&p);
- set_reg_value (&state[R_PC], addr);
- }
- rest_cpu_state ();
- return 0;
- }
- static signed char
- process_D (char *buffer) FASTCALL
- {/* 'D' - detach the program: continue execution */
- *buffer = '\0';
- return -2;
- }
- static signed char
- process_k (char *buffer) FASTCALL
- {/* 'k' - Kill the program */
- set_reg_value (&state[R_PC], 0);
- rest_cpu_state ();
- (void)buffer;
- return 0;
- }
- static signed char
- process_v (char *buffer) FASTCALL
- {
- #ifndef DBG_MIN_SIZE
- if (memcmp (&buffer[1], "Cont", 4) == 0)
- {
- if (buffer[5] == '?')
- {
- /* result response will be "vCont;c;C"; C action must be
- supported too, because GDB reguires at lease both of them */
- memcpy (&buffer[5], ";c;C", 5);
- return 0;
- }
- buffer[0] = '\0';
- if (buffer[5] == ';' && (buffer[6] == 'c' || buffer[6] == 'C'))
- return -2; /* resume execution */
- return 1;
- }
- #endif /* DBG_MIN_SIZE */
- return -1;
- }
- static signed char
- process_zZ (char *buffer) FASTCALL
- { /* insert/remove breakpoint */
- #if defined(DBG_SWBREAK_PROC) || defined(DBG_HWBREAK) || \
- defined(DBG_WWATCH) || defined(DBG_RWATCH) || defined(DBG_AWATCH)
- const byte set = (*buffer == 'Z');
- const char *p = &buffer[3];
- void *addr = (void*)hex2int(&p);
- if (*p != ',')
- return 1;
- p++;
- int kind = hex2int(&p);
- *buffer = '\0';
- switch (buffer[1])
- {
- #ifdef DBG_SWBREAK_PROC
- case '0': /* sw break */
- return DBG_SWBREAK_PROC(set, addr);
- #endif
- #ifdef DBG_HWBREAK
- case '1': /* hw break */
- return DBG_HWBREAK(set, addr);
- #endif
- #ifdef DBG_WWATCH
- case '2': /* write watch */
- return DBG_WWATCH(set, addr, kind);
- #endif
- #ifdef DBG_RWATCH
- case '3': /* read watch */
- return DBG_RWATCH(set, addr, kind);
- #endif
- #ifdef DBG_AWATCH
- case '4': /* access watch */
- return DBG_AWATCH(set, addr, kind);
- #endif
- default:; /* not supported */
- }
- #endif
- (void)buffer;
- return -1;
- }
- static signed char
- do_process (char *buffer) FASTCALL
- {
- switch (*buffer)
- {
- case '?': return process_question (buffer);
- case 'G': return process_G (buffer);
- case 'k': return process_k (buffer);
- case 'M': return process_M (buffer);
- case 'X': return process_X (buffer);
- case 'Z': return process_zZ (buffer);
- case 'c': return process_c (buffer);
- case 'D': return process_D (buffer);
- case 'g': return process_g (buffer);
- case 'm': return process_m (buffer);
- case 'q': return process_q (buffer);
- case 'v': return process_v (buffer);
- case 'z': return process_zZ (buffer);
- default: return -1; /* empty response */
- }
- }
- static char
- process (char *buffer) FASTCALL
- {
- signed char err = do_process (buffer);
- char *p = buffer;
- char ret = 1;
- if (err == -2)
- {
- ret = 0;
- err = 0;
- }
- if (err > 0)
- {
- *p++ = 'E';
- p = byte2hex (p, err);
- *p = '\0';
- }
- else if (err < 0)
- {
- *p = '\0';
- }
- else if (*p == '\0')
- memcpy(p, "OK", 3);
- return ret;
- }
- static char *
- byte2hex (char *p, byte v)
- {
- *p++ = high_hex (v);
- *p++ = low_hex (v);
- return p;
- }
- static signed char
- hex2val (unsigned char hex) FASTCALL
- {
- if (hex <= '9')
- return hex - '0';
- hex &= 0xdf; /* make uppercase */
- hex -= 'A' - 10;
- return (hex >= 10 && hex < 16) ? hex : -1;
- }
- static int
- hex2byte (const char *p) FASTCALL
- {
- signed char h = hex2val (p[0]);
- signed char l = hex2val (p[1]);
- if (h < 0 || l < 0)
- return -1;
- return (byte)((byte)h << 4) | (byte)l;
- }
- static int
- hex2int (const char **buf) FASTCALL
- {
- word r = 0;
- for (;; (*buf)++)
- {
- signed char a = hex2val(**buf);
- if (a < 0)
- break;
- r <<= 4;
- r += (byte)a;
- }
- return (int)r;
- }
- static char *
- int2hex (char *buf, int v)
- {
- buf = byte2hex(buf, (word)v >> 8);
- return byte2hex(buf, (byte)v);
- }
- static char
- high_hex (byte v) FASTCALL
- {
- return low_hex(v >> 4);
- }
- static char
- low_hex (byte v) FASTCALL
- {
- /*
- __asm
- ld a, l
- and a, #0x0f
- add a, #0x90
- daa
- adc a, #0x40
- daa
- ld l, a
- __endasm;
- (void)v;
- */
- v &= 0x0f;
- v += '0';
- if (v < '9'+1)
- return v;
- return v + 'a' - '0' - 10;
- }
- /* convert the memory, pointed to by mem into hex, placing result in buf */
- /* return a pointer to the last char put in buf (null) */
- static char *
- mem2hex (char *buf, const byte *mem, unsigned bytes)
- {
- char *d = buf;
- if (bytes != 0)
- {
- do
- {
- d = byte2hex (d, *mem++);
- }
- while (--bytes);
- }
- *d = 0;
- return d;
- }
- /* convert the hex array pointed to by buf into binary, to be placed in mem
- return a pointer to the character after the last byte written */
- static const char *
- hex2mem (byte *mem, const char *buf, unsigned bytes)
- {
- if (bytes != 0)
- {
- do
- {
- *mem++ = hex2byte (buf);
- buf += 2;
- }
- while (--bytes);
- }
- return buf;
- }
- #ifdef DBG_MEMORY_MAP
- static void
- read_memory_map (char *buffer, unsigned offset, unsigned length)
- {
- const char *map = DBG_MEMORY_MAP;
- const unsigned map_sz = strlen(map);
- if (offset >= map_sz)
- {
- buffer[0] = 'l';
- buffer[1] = '\0';
- return;
- }
- if (offset + length > map_sz)
- length = map_sz - offset;
- buffer[0] = 'm';
- memcpy (&buffer[1], &map[offset], length);
- buffer[1+length] = '\0';
- }
- #endif
- /* write string like " nn:0123" and return pointer after it */
- #ifndef DBG_MIN_SIZE
- static char *
- format_reg_value (char *p, unsigned reg_num, const byte *value)
- {
- char *d = p;
- unsigned char i;
- d = byte2hex(d, reg_num);
- *d++ = ':';
- value += REG_SIZE;
- i = REG_SIZE;
- do
- {
- d = byte2hex(d, *--value);
- }
- while (--i != 0);
- *d++ = ';';
- return d;
- }
- #endif /* DBG_MIN_SIZE */
- #ifdef __SDCC_gbz80
- /* saves all state.except PC and SP */
- static void
- save_cpu_state() __naked
- {
- __asm
- push af
- ld a, l
- ld (#_state + R_HL + 0), a
- ld a, h
- ld (#_state + R_HL + 1), a
- ld hl, #_state + R_HL - 1
- ld (hl), d
- dec hl
- ld (hl), e
- dec hl
- ld (hl), b
- dec hl
- ld (hl), c
- dec hl
- pop bc
- ld (hl), b
- dec hl
- ld (hl), c
- ret
- __endasm;
- }
- /* restore CPU state and continue execution */
- static void
- rest_cpu_state() __naked
- {
- __asm
- ;restore SP
- ld a, (#_state + R_SP + 0)
- ld l,a
- ld a, (#_state + R_SP + 1)
- ld h,a
- ld sp, hl
- ;push PC value as return address
- ld a, (#_state + R_PC + 0)
- ld l, a
- ld a, (#_state + R_PC + 1)
- ld h, a
- push hl
- ;restore registers
- ld hl, #_state + R_AF
- ld c, (hl)
- inc hl
- ld b, (hl)
- inc hl
- push bc
- ld c, (hl)
- inc hl
- ld b, (hl)
- inc hl
- ld e, (hl)
- inc hl
- ld d, (hl)
- inc hl
- ld a, (hl)
- inc hl
- ld h, (hl)
- ld l, a
- pop af
- ret
- __endasm;
- }
- #else
- /* saves all state.except PC and SP */
- static void
- save_cpu_state() __naked
- {
- __asm
- ld (#_state + R_HL), hl
- ld (#_state + R_DE), de
- ld (#_state + R_BC), bc
- push af
- pop hl
- ld (#_state + R_AF), hl
- ld a, r ;R is increased by 7 or by 8 if called via RST
- ld l, a
- sub a, #7
- xor a, l
- and a, #0x7f
- xor a, l
- #ifdef __SDCC_ez80_adl
- ld hl, i
- ex de, hl
- ld hl, #_state + R_IR
- ld (hl), a
- inc hl
- ld (hl), e
- inc hl
- ld (hl), d
- ld a, MB
- ld (#_state + R_AF+2), a
- #else
- ld l, a
- ld a, i
- ld h, a
- ld (#_state + R_IR), hl
- #endif /* __SDCC_ez80_adl */
- ld (#_state + R_IX), ix
- ld (#_state + R_IY), iy
- ex af, af' ;'
- exx
- ld (#_state + R_HL_), hl
- ld (#_state + R_DE_), de
- ld (#_state + R_BC_), bc
- push af
- pop hl
- ld (#_state + R_AF_), hl
- ret
- __endasm;
- }
- /* restore CPU state and continue execution */
- static void
- rest_cpu_state() __naked
- {
- __asm
- #ifdef DBG_USE_TRAMPOLINE
- ld sp, _stack + DBG_STACK_SIZE
- ld hl, (#_state + R_PC)
- push hl /* resume address */
- #ifdef __SDCC_ez80_adl
- ld hl, 0xc30000 ; use 0xc34000 for jp.s
- #else
- ld hl, 0xc300
- #endif
- push hl /* JP opcode */
- #endif /* DBG_USE_TRAMPOLINE */
- ld hl, (#_state + R_AF_)
- push hl
- pop af
- ld bc, (#_state + R_BC_)
- ld de, (#_state + R_DE_)
- ld hl, (#_state + R_HL_)
- exx
- ex af, af' ;'
- ld iy, (#_state + R_IY)
- ld ix, (#_state + R_IX)
- #ifdef __SDCC_ez80_adl
- ld a, (#_state + R_AF + 2)
- ld MB, a
- ld hl, (#_state + R_IR + 1) ;I register
- ld i, hl
- ld a, (#_state + R_IR + 0) ; R register
- ld l, a
- #else
- ld hl, (#_state + R_IR)
- ld a, h
- ld i, a
- ld a, l
- #endif /* __SDCC_ez80_adl */
- sub a, #10 ;number of M1 cycles after ld r,a
- xor a, l
- and a, #0x7f
- xor a, l
- ld r, a
- ld de, (#_state + R_DE)
- ld bc, (#_state + R_BC)
- ld hl, (#_state + R_AF)
- push hl
- pop af
- ld sp, (#_state + R_SP)
- #ifndef DBG_USE_TRAMPOLINE
- ld hl, (#_state + R_PC)
- push hl
- ld hl, (#_state + R_HL)
- DBG_RESUME
- #else
- ld hl, (#_state + R_HL)
- #ifdef __SDCC_ez80_adl
- jp #_stack + DBG_STACK_SIZE - 4
- #else
- jp #_stack + DBG_STACK_SIZE - 3
- #endif
- #endif /* DBG_USE_TRAMPOLINE */
- __endasm;
- }
- #endif /* __SDCC_gbz80 */
|