X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fgldbg.cpp;h=c37e65552a3684c5681284e5821959829d79648b;hb=a832996c884a0e0acc9a38ba4dd258edb75ec7af;hp=43827378f4faed462e35efe2be4b3a2ca2dfffcb;hpb=ea3d851aa52e999b1c5a5fa52c97ff5019756c0e;p=gldbg.git diff --git a/source/gldbg.cpp b/source/gldbg.cpp index 4382737..c37e655 100644 --- a/source/gldbg.cpp +++ b/source/gldbg.cpp @@ -1,40 +1,40 @@ -/* $Id$ - -This file is part of gldbg -Copyright © 2009-2010 Mikko Rasa, Mikkosoft Productions -Distributed under the GPL -*/ - +#include +#include #include +#include #include #include +#include #include #include #include -#include -#include -#include -#include #include "functions.h" #include "gldbg.h" #include "gldecoder.h" #include "packet.h" +#include "strformat.h" #include "tool.h" using namespace std; -using namespace Msp; -Application::RegApp GlDbg::reg; +GlDbg *GlDbg::instance = 0; GlDbg::GlDbg(int argc, char **argv): cmd_interp(*this), 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()); + instance = this; + + char buf[PATH_MAX]; + unsigned len = readlink("/proc/self/exe", buf, sizeof(buf)); + string exe(buf, len); + string::size_type slash = exe.rfind('/'); + process.setenv("LD_PRELOAD", (exe.substr(0, slash+1)+"glwrap.so")); const list &factories = Tool::get_factories(); for(list::const_iterator i=factories.begin(); i!=factories.end(); ++i) @@ -43,21 +43,21 @@ 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; } int GlDbg::main() { - catch_signal(SIGINT); - catch_signal(SIGCHLD); - set_loop_mode(TICK_BUSY); + signal(SIGINT, &sighandler); + signal(SIGCHLD, &sighandler); - IO::print("GLdbg 0.0\n"); - IO::print("Copyright © 2009-2010 Mikkosoft Productions\n"); - IO::print("Type \"help\" for a list of commands\n"); + printf("GLdbg 0.0\n"); + printf("Copyright © 2009-2010 Mikkosoft Productions\n"); + printf("Type \"help\" for a list of commands\n"); - Application::main(); + while(1) + tick(); return 0; } @@ -65,7 +65,7 @@ int GlDbg::main() void GlDbg::launch() { if(process.get_state()!=Process::INACTIVE) - throw InvalidState("Program is already running"); + throw runtime_error("Program is already running"); int fds[2]; socketpair(AF_UNIX, SOCK_STREAM, 0, fds); @@ -74,34 +74,93 @@ void GlDbg::launch() int flags = fcntl(sock_fd, F_GETFD); fcntl(sock_fd, F_SETFD, flags|FD_CLOEXEC); - process.setenv("GLWRAP_FD", lexical_cast(fds[1])); - process.setenv("GLWRAP_CTRL_FD", lexical_cast(fds[1])); + process.setenv("GLWRAP_FD", strformat("%d", fds[1])); + process.setenv("GLWRAP_CTRL_FD", strformat("%d", 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(!force && process.get_state()!=Process::INACTIVE) - throw InvalidState("Program is still running"); + throw runtime_error("Program is still running"); exit(0); } @@ -110,18 +169,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 +179,20 @@ void GlDbg::tick() read_stream(); else { + if(stop_reason) + { + if(stop_reason==0x100) + printf("Target process exited normally\n"); + else if((stop_reason>>8)==1) + printf("Target process exited with status %d\n", stop_reason&0xFF); + else if((stop_reason>>8)==2) + printf("Target process terminated with signal %d\n", stop_reason&0xFF); + else if((stop_reason>>8)==3) + printf("Target process stopped by signal %d\n", stop_reason&0xFF); + + stop_reason = 0; + } + char *line = readline("gldbg> "); if(line) { @@ -136,9 +200,9 @@ void GlDbg::tick() { cmd_interp.execute(line); } - catch(const Exception &e) + catch(const exception &e) { - IO::print("%s\n", e.what()); + printf("%s\n", e.what()); } free(line); } @@ -171,10 +235,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) + printf("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,11 +262,57 @@ 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) { if(sig==SIGCHLD) - got_sigchld = true; + instance->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); }