X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fgldbg.cpp;fp=source%2Fgldbg.cpp;h=001742d39599b85942702f797d8e8ed383d7a16d;hb=6d297b506314c07bff3d77c2853a5f59380cfcb0;hp=43827378f4faed462e35efe2be4b3a2ca2dfffcb;hpb=8ddb049bf9cb06c377857ab46b7af23c140f12a7;p=gldbg.git diff --git a/source/gldbg.cpp b/source/gldbg.cpp index 4382737..001742d 100644 --- a/source/gldbg.cpp +++ b/source/gldbg.cpp @@ -5,6 +5,7 @@ Copyright © 2009-2010 Mikko Rasa, Mikkosoft Productions Distributed under the GPL */ +#include #include #include #include @@ -31,7 +32,9 @@ GlDbg::GlDbg(int argc, char **argv): process(vector(argv+1, argv+argc)), buf_offset(0), flushing(false), - got_sigchld(false) + got_sigchld(false), + stop_reason(0), + current_break(0) { FS::Path libdir = FS::get_sys_lib_dir(argv[0], "gldbg"); process.setenv("LD_PRELOAD", (libdir/"glwrap.so").str().c_str()); @@ -43,7 +46,7 @@ GlDbg::GlDbg(int argc, char **argv): GlDbg::~GlDbg() { - for(list::iterator i=tools.begin(); i!=tools.end(); ++i) + for(ToolList::iterator i=tools.begin(); i!=tools.end(); ++i) delete *i; } @@ -78,24 +81,83 @@ void GlDbg::launch() process.setenv("GLWRAP_CTRL_FD", lexical_cast(fds[1])); process.launch(); close(fds[1]); + + breakpoints.clear(); + for(ToolList::iterator i=tools.begin(); i!=tools.end(); ++i) + (*i)->process_started(); } -void GlDbg::set_breakpoint(unsigned short func, char flag) +void GlDbg::send(GlPacket *pkt) { - GlPacket *pkt = packet_begin(FUNC_GLDBREAK); - packet_write_short(pkt, func); - packet_write_char(pkt, flag); - packet_write_char(pkt, 0); packet_send(pkt, sock_fd); } -void GlDbg::clear_breakpoint(unsigned short func, char flag) +void GlDbg::hold() { - GlPacket *pkt = packet_begin(FUNC_GLDBREAK); - packet_write_short(pkt, func); - packet_write_char(pkt, 0); - packet_write_char(pkt, flag); - packet_send(pkt, sock_fd); + GlPacket *pkt = packet_begin(FUNC_GLDHOLD); + send(pkt); +} + +void GlDbg::set_breakpoint(unsigned short func, unsigned char flag, Tool *owner) +{ + Breakpoint *bp = (func ? get_breakpoint(func, flag) : 0); + if(bp) + bp->add_owner(owner); + else + { + if(func) + { + breakpoints.push_back(Breakpoint(func, flag)); + breakpoints.back().add_owner(owner); + } + + GlPacket *pkt = packet_begin(FUNC_GLDBREAK); + packet_write_short(pkt, func); + packet_write_char(pkt, flag); + packet_write_char(pkt, 0); + send(pkt); + } +} + +void GlDbg::clear_breakpoint(unsigned short func, unsigned char flag, Tool *owner) +{ + Breakpoint *bp = get_breakpoint(func, flag); + if(bp) + { + bp->remove_owner(owner); + if(bp->owners.empty()) + { + if(current_break==bp) + current_break = 0; + + // XXX Inefficient. Should get_breakpoint() return an iterator? + for(BreakList::iterator i=breakpoints.begin(); i!=breakpoints.end(); ++i) + if(i->function==func && i->flag==flag) + { + breakpoints.erase(i); + break; + } + + GlPacket *pkt = packet_begin(FUNC_GLDBREAK); + packet_write_short(pkt, func); + packet_write_char(pkt, 0); + packet_write_char(pkt, flag); + send(pkt); + } + } +} + +void GlDbg::resume_from_break(Tool *tool) +{ + if(!current_break) + return; + + ToolList::iterator i = find(break_holders.begin(), break_holders.end(), tool); + if(i!=break_holders.end()) + break_holders.erase(i); + + if(break_holders.empty()) + process.resume(); } void GlDbg::quit(bool force) @@ -110,18 +172,9 @@ void GlDbg::tick() if(got_sigchld) { got_sigchld = false; - int ret = process.check(); - if(ret==0x100) - IO::print("Target process exited normally\n"); - else if((ret>>8)==1) - IO::print("Target process exited with status %d\n", ret&0xFF); - else if((ret>>8)==2) - IO::print("Target process terminated with signal %d\n", ret&0xFF); - else if((ret>>8)==3) - { - IO::print("Target process stopped by signal %d\n", ret&0xFF); + stop_reason = process.check(); + if((stop_reason>>8)==3) flushing = true; - } } Process::State pstate = process.get_state(); @@ -129,6 +182,20 @@ void GlDbg::tick() read_stream(); else { + if(stop_reason) + { + if(stop_reason==0x100) + IO::print("Target process exited normally\n"); + else if((stop_reason>>8)==1) + IO::print("Target process exited with status %d\n", stop_reason&0xFF); + else if((stop_reason>>8)==2) + IO::print("Target process terminated with signal %d\n", stop_reason&0xFF); + else if((stop_reason>>8)==3) + IO::print("Target process stopped by signal %d\n", stop_reason&0xFF); + + stop_reason = 0; + } + char *line = readline("gldbg> "); if(line) { @@ -171,10 +238,22 @@ void GlDbg::read_stream() if(func==FUNC_GLDBREAK) { packet_read_short(pkt, (short *)&func); - IO::print("Breakpoint: %s\n", get_function_name(func)); + unsigned char flag; + packet_read_char(pkt, (char *)&flag); + + current_break = get_breakpoint(func, flag); + bool announce = !current_break; + if(current_break) + { + break_holders = current_break->owners; + announce = current_break->has_owner(0); + } + + if(announce) + IO::print("Breakpoint: %s\n", get_function_name(func)); } - for(list::iterator i=tools.begin(); i!=tools.end(); ++i) + for(ToolList::iterator i=tools.begin(); i!=tools.end(); ++i) (*i)->decode(data, len); buf_offset += len; } @@ -186,7 +265,27 @@ void GlDbg::read_stream() } } else if(flushing) + { flushing = false; + + if(stop_reason) + { + for(ToolList::iterator i=tools.begin(); i!=tools.end(); ++i) + (*i)->process_stopped(stop_reason); + + if(process.get_state()==Process::RUNNING) + current_break = 0; + } + } +} + +GlDbg::Breakpoint *GlDbg::get_breakpoint(unsigned short func, unsigned char flag) +{ + for(BreakList::iterator i=breakpoints.begin(); i!=breakpoints.end(); ++i) + if(i->function==func && i->flag==flag) + return &*i; + + return 0; } void GlDbg::sighandler(int sig) @@ -194,3 +293,29 @@ void GlDbg::sighandler(int sig) if(sig==SIGCHLD) got_sigchld = true; } + + +GlDbg::Breakpoint::Breakpoint(unsigned short f, unsigned char l): + function(f), + flag(l) +{ } + +void GlDbg::Breakpoint::add_owner(Tool *t) +{ + ToolList::iterator i = find(owners.begin(), owners.end(), t); + if(i==owners.end()) + owners.push_back(t); +} + +bool GlDbg::Breakpoint::has_owner(Tool *t) const +{ + ToolList::const_iterator i = find(owners.begin(), owners.end(), t); + return i!=owners.end(); +} + +void GlDbg::Breakpoint::remove_owner(Tool *t) +{ + ToolList::iterator i = find(owners.begin(), owners.end(), t); + if(i!=owners.end()) + owners.erase(i); +}