Distributed under the GPL
*/
+#include <algorithm>
#include <cstdlib>
#include <fcntl.h>
#include <signal.h>
process(vector<string>(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());
GlDbg::~GlDbg()
{
- for(list<Tool *>::iterator i=tools.begin(); i!=tools.end(); ++i)
+ for(ToolList::iterator i=tools.begin(); i!=tools.end(); ++i)
delete *i;
}
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)
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();
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)
{
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<Tool *>::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;
}
}
}
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)
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);
+}
projects / gldbg.git / blobdiff