#include "debugger_c.h" #include #include #include typedef struct sleela_debugger_breakpoint { uint64_t id; char *function; sleela_debugger_location_t location; } sleela_debugger_breakpoint_t; typedef struct sleela_debugger_watchpoint { uint64_t id; char *expression; } sleela_debugger_watchpoint_t; typedef struct sleela_debugger_event_copy { sleela_debugger_event_type_t type; char *severity,*message,*thread,*file; sleela_debugger_location_t location; } sleela_debugger_event_copy_t; typedef struct sleela_debugger_evidence_copy { uint64_t sequence; char *observation,*event,*file,*thread,*stack_summary,*action,*backend_result,*diagnostic; sleela_debugger_location_t source; } sleela_debugger_evidence_copy_t; struct sleela_debugger_session { uint64_t next_id,next_evidence; sleela_debugger_breakpoint_t *breakpoints; size_t breakpoint_count,breakpoint_capacity; sleela_debugger_watchpoint_t *watchpoints; size_t watchpoint_count,watchpoint_capacity; sleela_debugger_event_copy_t *events; size_t event_count,event_capacity; sleela_debugger_evidence_copy_t *evidence; size_t evidence_count,evidence_capacity; sleela_debugger_stop_record_t stop; char *stop_thread,*stop_detail,*stop_file; }; static char *dup_s(const char *v){size_t n;char *p;if(!v)return NULL;n=strlen(v)+1u;p=(char*)malloc(n);if(!p)return NULL;memcpy(p,v,n);return p;} static int grow(void **ptr,size_t *cap,size_t count,size_t sz){size_t next;void *p;if(count<*cap)return 1;next=*cap?*cap*2u:8u;if(nextseverity);free(e->message);free(e->thread);free(e->file);memset(e,0,sizeof(*e));} static void free_evidence(sleela_debugger_evidence_copy_t *e){if(!e)return;free(e->observation);free(e->event);free(e->file);free(e->thread);free(e->stack_summary);free(e->action);free(e->backend_result);free(e->diagnostic);memset(e,0,sizeof(*e));} static const char *event_name(sleela_debugger_event_type_t t){switch(t){case SLEELA_DEBUGGER_EVENT_INFO:return "info";case SLEELA_DEBUGGER_EVENT_BREAKPOINT:return "breakpoint";case SLEELA_DEBUGGER_EVENT_WATCHPOINT:return "watchpoint";case SLEELA_DEBUGGER_EVENT_EXCEPTION:return "exception";case SLEELA_DEBUGGER_EVENT_ASSERTION:return "assertion";case SLEELA_DEBUGGER_EVENT_THREAD:return "thread";case SLEELA_DEBUGGER_EVENT_LOG:return "log";case SLEELA_DEBUGGER_EVENT_COVERAGE:return "coverage";case SLEELA_DEBUGGER_EVENT_SANITIZER:return "sanitizer";case SLEELA_DEBUGGER_EVENT_TEST:return "test";case SLEELA_DEBUGGER_EVENT_REGRESSION:return "regression";case SLEELA_DEBUGGER_EVENT_CRASH:return "crash";}return "unknown";} static const char *stop_name(sleela_debugger_stop_reason_t r){switch(r){case SLEELA_DEBUGGER_STOP_NONE:return "none";case SLEELA_DEBUGGER_STOP_BREAKPOINT:return "breakpoint";case SLEELA_DEBUGGER_STOP_WATCHPOINT:return "watchpoint";case SLEELA_DEBUGGER_STOP_EXCEPTION:return "exception";case SLEELA_DEBUGGER_STOP_SIGNAL:return "signal";case SLEELA_DEBUGGER_STOP_ASSERTION:return "assertion";case SLEELA_DEBUGGER_STOP_SANITIZER:return "sanitizer";case SLEELA_DEBUGGER_STOP_CRASH:return "crash";case SLEELA_DEBUGGER_STOP_USER_PAUSE:return "user-pause";case SLEELA_DEBUGGER_STOP_TEST_FAILURE:return "test-failure";}return "unknown";} sleela_debugger_session_t *sleela_debugger_create(void){sleela_debugger_session_t*s=(sleela_debugger_session_t*)calloc(1,sizeof(*s));if(s){s->next_id=1;s->next_evidence=1;}return s;} void sleela_debugger_destroy(sleela_debugger_session_t*s){size_t i;if(!s)return;for(i=0;ibreakpoint_count;i++)free(s->breakpoints[i].function);for(i=0;iwatchpoint_count;i++)free(s->watchpoints[i].expression);for(i=0;ievent_count;i++)free_event(&s->events[i]);for(i=0;ievidence_count;i++)free_evidence(&s->evidence[i]);free(s->stop_thread);free(s->stop_detail);free(s->stop_file);free(s->breakpoints);free(s->watchpoints);free(s->events);free(s->evidence);free(s);} uint64_t sleela_debugger_add_breakpoint(sleela_debugger_session_t*s,const char*f,const sleela_debugger_location_t*l){sleela_debugger_breakpoint_t*b;if(!s||!f)return 0;if(!grow((void**)&s->breakpoints,&s->breakpoint_capacity,s->breakpoint_count,sizeof(*s->breakpoints)))return 0;b=&s->breakpoints[s->breakpoint_count++];memset(b,0,sizeof(*b));b->function=dup_s(f);if(!b->function){--s->breakpoint_count;return 0;}if(l)b->location=*l;b->id=s->next_id++;return b->id;} uint64_t sleela_debugger_add_watchpoint(sleela_debugger_session_t*s,const char*x){sleela_debugger_watchpoint_t*w;if(!s||!x)return 0;if(!grow((void**)&s->watchpoints,&s->watchpoint_capacity,s->watchpoint_count,sizeof(*s->watchpoints)))return 0;w=&s->watchpoints[s->watchpoint_count++];memset(w,0,sizeof(*w));w->expression=dup_s(x);if(!w->expression){--s->watchpoint_count;return 0;}w->id=s->next_id++;return w->id;} sleela_debugger_result_t sleela_debugger_remove_breakpoint(sleela_debugger_session_t*s,uint64_t id){size_t i;if(!s||!id)return SLEELA_DEBUGGER_INVALID_ARGUMENT;for(i=0;ibreakpoint_count;i++)if(s->breakpoints[i].id==id){free(s->breakpoints[i].function);s->breakpoints[i]=s->breakpoints[--s->breakpoint_count];return SLEELA_DEBUGGER_OK;}return SLEELA_DEBUGGER_NOT_FOUND;} sleela_debugger_result_t sleela_debugger_remove_watchpoint(sleela_debugger_session_t*s,uint64_t id){size_t i;if(!s||!id)return SLEELA_DEBUGGER_INVALID_ARGUMENT;for(i=0;iwatchpoint_count;i++)if(s->watchpoints[i].id==id){free(s->watchpoints[i].expression);s->watchpoints[i]=s->watchpoints[--s->watchpoint_count];return SLEELA_DEBUGGER_OK;}return SLEELA_DEBUGGER_NOT_FOUND;} sleela_debugger_result_t sleela_debugger_emit(sleela_debugger_session_t*s,const sleela_debugger_event_t*e){sleela_debugger_event_copy_t*d;if(!s||!e)return SLEELA_DEBUGGER_INVALID_ARGUMENT;if(!grow((void**)&s->events,&s->event_capacity,s->event_count,sizeof(*s->events)))return SLEELA_DEBUGGER_IO_ERROR;d=&s->events[s->event_count++];memset(d,0,sizeof(*d));d->type=e->type;d->severity=dup_s(e->severity?e->severity:"info");d->message=dup_s(e->message?e->message:"");d->thread=dup_s(e->thread?e->thread:"");d->file=dup_s(e->location.file?e->location.file:"");d->location.line=e->location.line;d->location.column=e->location.column;d->location.file=d->file;if(!d->severity||!d->message||!d->thread||!d->file){free_event(d);--s->event_count;return SLEELA_DEBUGGER_IO_ERROR;}if(e->type==SLEELA_DEBUGGER_EVENT_BREAKPOINT)s->stop.reason=SLEELA_DEBUGGER_STOP_BREAKPOINT;else if(e->type==SLEELA_DEBUGGER_EVENT_WATCHPOINT)s->stop.reason=SLEELA_DEBUGGER_STOP_WATCHPOINT;else if(e->type==SLEELA_DEBUGGER_EVENT_EXCEPTION)s->stop.reason=SLEELA_DEBUGGER_STOP_EXCEPTION;else if(e->type==SLEELA_DEBUGGER_EVENT_ASSERTION)s->stop.reason=SLEELA_DEBUGGER_STOP_ASSERTION;else if(e->type==SLEELA_DEBUGGER_EVENT_SANITIZER)s->stop.reason=SLEELA_DEBUGGER_STOP_SANITIZER;else if(e->type==SLEELA_DEBUGGER_EVENT_CRASH)s->stop.reason=SLEELA_DEBUGGER_STOP_CRASH;if(s->stop.reason!=SLEELA_DEBUGGER_STOP_NONE){free(s->stop_thread);free(s->stop_detail);free(s->stop_file);s->stop_thread=dup_s(e->thread?e->thread:"");s->stop_detail=dup_s(e->message?e->message:"");s->stop_file=dup_s(e->location.file?e->location.file:"");s->stop.thread=s->stop_thread;s->stop.detail=s->stop_detail;s->stop.location=e->location;s->stop.location.file=s->stop_file;}return SLEELA_DEBUGGER_OK;} size_t sleela_debugger_event_count(const sleela_debugger_session_t*s){return s?s->event_count:0;} sleela_debugger_result_t sleela_debugger_set_stop_record(sleela_debugger_session_t*s,const sleela_debugger_stop_record_t*r){if(!s||!r)return SLEELA_DEBUGGER_INVALID_ARGUMENT;free(s->stop_thread);free(s->stop_detail);free(s->stop_file);s->stop=*r;s->stop_thread=dup_s(r->thread?r->thread:"");s->stop_detail=dup_s(r->detail?r->detail:"");s->stop_file=dup_s(r->location.file?r->location.file:"");if(!s->stop_thread||!s->stop_detail||!s->stop_file)return SLEELA_DEBUGGER_IO_ERROR;s->stop.thread=s->stop_thread;s->stop.detail=s->stop_detail;s->stop.location.file=s->stop_file;return SLEELA_DEBUGGER_OK;} sleela_debugger_result_t sleela_debugger_add_evidence(sleela_debugger_session_t*s,const sleela_debugger_evidence_t*e,uint64_t*out){sleela_debugger_evidence_copy_t*d;if(!s||!e)return SLEELA_DEBUGGER_INVALID_ARGUMENT;if(!grow((void**)&s->evidence,&s->evidence_capacity,s->evidence_count,sizeof(*s->evidence)))return SLEELA_DEBUGGER_IO_ERROR;d=&s->evidence[s->evidence_count++];memset(d,0,sizeof(*d));d->sequence=s->next_evidence++;d->observation=dup_s(e->observation?e->observation:"");d->event=dup_s(e->event?e->event:"");d->file=dup_s(e->source.file?e->source.file:"");d->thread=dup_s(e->thread?e->thread:"");d->stack_summary=dup_s(e->stack_summary?e->stack_summary:"");d->action=dup_s(e->action?e->action:"");d->backend_result=dup_s(e->backend_result?e->backend_result:"");d->diagnostic=dup_s(e->diagnostic?e->diagnostic:"");d->source=e->source;d->source.file=d->file;if(!d->observation||!d->event||!d->file||!d->thread||!d->stack_summary||!d->action||!d->backend_result||!d->diagnostic){free_evidence(d);--s->evidence_count;return SLEELA_DEBUGGER_IO_ERROR;}if(out)*out=d->sequence;return SLEELA_DEBUGGER_OK;} size_t sleela_debugger_evidence_count(const sleela_debugger_session_t*s){return s?s->evidence_count:0;} sleela_debugger_result_t sleela_debugger_write_report(const sleela_debugger_session_t*s,const char*path){FILE*out;size_t i;if(!s||!path)return SLEELA_DEBUGGER_INVALID_ARGUMENT;out=fopen(path,"w");if(!out)return SLEELA_DEBUGGER_IO_ERROR;fprintf(out,"SLeeLa Debugger C Diagnostic Report\nabi=%u events=%zu evidence=%zu\n",(unsigned)SLEELA_DEBUGGER_C_ABI_VERSION,s->event_count,s->evidence_count);if(s->stop.reason!=SLEELA_DEBUGGER_STOP_NONE)fprintf(out,"stop_reason=%s detail=%s\n",stop_name(s->stop.reason),s->stop_detail?s->stop_detail:"");for(i=0;ievent_count;i++){const sleela_debugger_event_copy_t*e=&s->events[i];fprintf(out,"[%s] %s: %s",e->severity,event_name(e->type),e->message);if(e->thread&&e->thread[0])fprintf(out," thread=%s",e->thread);if(e->file&&e->file[0])fprintf(out," %s:%u:%u",e->file,(unsigned)e->location.line,(unsigned)e->location.column);fputc('\n',out);}for(i=0;ievidence_count;i++){const sleela_debugger_evidence_copy_t*e=&s->evidence[i];fprintf(out,"evidence#%llu observation=%s event=%s", (unsigned long long)e->sequence,e->observation,e->event);if(e->file&&e->file[0])fprintf(out," source=%s:%u:%u",e->file,(unsigned)e->source.line,(unsigned)e->source.column);if(e->thread&&e->thread[0])fprintf(out," thread=%s",e->thread);if(e->action&&e->action[0])fprintf(out," action=%s",e->action);if(e->backend_result&&e->backend_result[0])fprintf(out," backend=%s",e->backend_result);if(e->diagnostic&&e->diagnostic[0])fprintf(out," diagnostic=%s",e->diagnostic);fputc('\n',out);}if(fclose(out)!=0)return SLEELA_DEBUGGER_IO_ERROR;return SLEELA_DEBUGGER_OK;} const char *sleela_debugger_result_string(sleela_debugger_result_t r){switch(r){case SLEELA_DEBUGGER_OK:return "ok";case SLEELA_DEBUGGER_INVALID_ARGUMENT:return "invalid-argument";case SLEELA_DEBUGGER_NOT_FOUND:return "not-found";case SLEELA_DEBUGGER_IO_ERROR:return "io-error";}return "unknown";}