common/trace_profiler.cpp
common/trace_option.cpp
common/${os}
+ common/trace_backtrace.cpp
)
set_target_properties (common PROPERTIES
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2013 Samsung
+ * Contributed by Eugene Velesevich
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+
+/*
+ * Wrapper for platform-specific code for obtaining symbolic backtraces
+ * on Android and Linux
+ */
+
+
+
+#include "trace_backtrace.hpp"
+
+#if defined(ANDROID) or defined(__linux__)
+
+#include <set>
+#include "os.hpp"
+
+
+namespace trace {
+
+/*
+ * Pascal string (with zero terminator optionally omitted)
+ * This is a helper class for storing a set of exact strings or prefixes
+ * to match a zero-terminated string against later.
+ * Two zero-terminated pstrings compare equal iff they are the same.
+ * Otherwise, they compare equal iff one is a prefix of the other
+ * (a zero-terminated pstring cannot be a prefix)
+ */
+
+struct pstring {
+ const char* s;
+ int n;
+ pstring(const char* s, int n)
+ {
+ this->s = s;
+ this->n = n;
+ }
+ bool operator<(const pstring q2) const
+ {
+ return memcmp(s, q2.s, n < q2.n? n : q2.n) < 0;
+ }
+};
+
+
+#define PREFIX_BUF_SIZE (PREFIX_MAX_FUNC_NAME * MAX_BT_FUNC)
+
+class StringPrefixes {
+private:
+ std::set<pstring> pset;
+ char* buf;
+private:
+ void addPrefix(char* startbuf, int n) {
+ std::set<pstring>::iterator elem = pset.find(pstring(startbuf, n));
+ bool replace = elem != pset.end() && n < elem->n;
+ if (replace) {
+ pset.erase(elem);
+ }
+ if (replace || elem == pset.end()) {
+ pset.insert(pstring(startbuf, n));
+ }
+ }
+public:
+ StringPrefixes(const char* source);
+
+ bool contain(const char* s) {
+ if (pset.find(pstring(s, strlen(s) + 1)) != pset.end()) {
+ os::log("Backtrace for %s is enabled", s);
+ return true;
+ }
+ return false;
+ }
+};
+
+bool backtrace_is_needed(const char* fname) {
+ static StringPrefixes backtraceFunctionNamePrefixes(APITRACE_FNAMES_SOURCE);
+ return backtraceFunctionNamePrefixes.contain(fname);
+}
+
+} /* namespace trace */
+
+#ifdef ANDROID
+
+#include <dlfcn.h>
+#include "os.hpp"
+#include <vector>
+
+namespace trace {
+
+StringPrefixes::StringPrefixes(const char* source) {
+ buf = (char*)malloc(sizeof(char) * PREFIX_BUF_SIZE);
+ char* startbuf = buf;
+ int n = 0;
+ FILE* f = fopen(source, "r");
+ if (f == NULL) {
+ os::log("Cannot open " APITRACE_FNAMES_FILE);
+ }
+ while ((startbuf = fgets(startbuf, PREFIX_MAX_FUNC_NAME, f))) {
+ n = strlen(startbuf);
+ if (startbuf[n - 1] == '\n') {
+ n--;
+ }
+ if (n > 2 && startbuf[0] != '#') {
+ int psize;
+ if (startbuf[n - 1] != '*') {
+ startbuf[n] = '\0';
+ psize = n + 1;
+ }
+ else {
+ psize = n - 1;
+ }
+ addPrefix(startbuf, psize);
+ startbuf += n + 1;
+ n = 0;
+ }
+ }
+ fclose(f);
+}
+
+
+/* The following two declarations are copied from Android sources */
+
+enum DebugTargetKind {
+ kDebugTargetUnknown = 0,
+ kDebugTargetLog,
+ kDebugTargetFile,
+};
+
+struct DebugOutputTarget {
+ DebugTargetKind which;
+
+ union {
+ struct {
+ int priority;
+ const char* tag;
+ } log;
+ struct {
+ FILE* fp;
+ } file;
+ } data;
+};
+
+#define THREAD_SELF_NAME "_Z13dvmThreadSelfv"
+#define CREATE_DEBUG_TARGET_NAME "_Z25dvmCreateFileOutputTargetP17DebugOutputTargetP7__sFILE"
+#define DUMP_BACKTRACE_NAME "_Z18dvmDumpThreadStackPK17DebugOutputTargetP6Thread"
+
+
+class DalvikBacktraceProvider {
+private:
+ bool errorOccured;
+ void* (*threadself)(void);
+ FILE* streamInMemory;
+ char* buf;
+ size_t bufSize;
+ void (*dumpBacktrace)(const DebugOutputTarget*, void*);
+ DebugOutputTarget debugTarget;
+public:
+ DalvikBacktraceProvider() {
+ FILE* (*open_memstream_exp)(char**, size_t*);
+ void (*createDebugTarget)(DebugOutputTarget*, FILE*);
+ void* handle = dlopen("/system/lib/libdvm.so", 0);
+ errorOccured = true;
+ if (!handle) {
+ os::log("dlopen failed\n");
+ return;
+ }
+ threadself = (void* (*)())dlsym(handle, THREAD_SELF_NAME);
+ if (threadself == NULL) {
+ os::log("dlsym ThreadSelf failed\n");
+ return;
+ }
+ createDebugTarget = (void (*)(DebugOutputTarget*, FILE*))dlsym(handle, CREATE_DEBUG_TARGET_NAME);
+ if (createDebugTarget == NULL) {
+ os::log("dlsym CreateFileOutput failed\n");
+ return;
+ }
+ dumpBacktrace = (void (*)(const DebugOutputTarget*, void*))dlsym(handle, DUMP_BACKTRACE_NAME);
+ if (dumpBacktrace == NULL) {
+ os::log("dlsym DumpThreadStack failed\n");
+ return;
+ }
+ void* handle2 = dlopen("/system/lib/libcutils.so", 0);
+ if (!handle2) {
+ os::log("dlopen failed\n");
+ return;
+ }
+ open_memstream_exp = (FILE* (*)(char**, size_t*))dlsym(handle2, "open_memstream");
+ if (open_memstream_exp == NULL) {
+ os::log("dlsym open_memstream failed\n");
+ return;
+ }
+ streamInMemory = open_memstream_exp(&buf, &bufSize);
+ if (streamInMemory == NULL) {
+ os::log("open_memstream failed\n");
+ return;
+ }
+ createDebugTarget(&debugTarget, streamInMemory);
+ errorOccured = false;
+ }
+
+ inline char* getBacktrace() {
+ if (errorOccured) {
+ return NULL;
+ }
+ rewind(streamInMemory);
+ dumpBacktrace(&debugTarget, threadself());
+ fflush(streamInMemory);
+ return buf;
+ }
+/*
+ * Parse a stack frame, expecting:
+ * " at android.view.HardwareRenderer$GlRenderer.initializeEgl(HardwareRenderer.java:547)"
+ * or
+ * " at android.view.HardwareRenderer$GlRenderer.initializeEgl(Native Method)"
+ */
+ std::vector<RawStackFrame> parseBacktrace(char *rawBacktrace) {
+ std::vector<RawStackFrame> parsedBacktrace;
+ char* rawBacktrace_it = rawBacktrace;
+ while (*rawBacktrace_it != '\0') {
+ RawStackFrame stackFrame;
+ /* skip leading space */
+ while (*rawBacktrace_it == ' ') {
+ rawBacktrace_it++;
+ }
+ /* Skip "at " */
+ rawBacktrace_it += 3;
+ stackFrame.function = rawBacktrace_it;
+ while (*rawBacktrace_it != '(') {
+ rawBacktrace_it++;
+ }
+ *rawBacktrace_it = '\0';
+ stackFrame.filename = rawBacktrace_it + 1;
+ while (*rawBacktrace_it != ':' && *rawBacktrace_it != ')') {
+ rawBacktrace_it++;
+ }
+ if (*rawBacktrace_it == ':') {
+ stackFrame.linenumber = rawBacktrace_it + 1;
+ *rawBacktrace_it = '\0';
+ while (*rawBacktrace_it != ')') {
+ rawBacktrace_it++;
+ }
+ *rawBacktrace_it = '\0';
+ rawBacktrace_it++;
+ }
+ else {
+ stackFrame.filename = NULL;
+ while (*rawBacktrace_it != '\n') {
+ rawBacktrace_it++;
+ }
+ }
+ while (*rawBacktrace_it == '\n' || *rawBacktrace_it == ' ') {
+ rawBacktrace_it++;
+ }
+ parsedBacktrace.push_back(stackFrame); /* module */
+ }
+ return parsedBacktrace;
+ }
+};
+
+std::vector<RawStackFrame> get_backtrace() {
+ static DalvikBacktraceProvider backtraceProvider;
+ return backtraceProvider.parseBacktrace(backtraceProvider.getBacktrace());
+}
+
+/* end ANDROID */
+#elif defined __linux__
+
+#include <execinfo.h>
+#include <string.h>
+#include <stdlib.h>
+#include <map>
+#include <vector>
+#include <stdio.h>
+
+namespace trace {
+
+
+StringPrefixes::StringPrefixes(const char* source) {
+ buf = (char*)malloc(sizeof(char) * PREFIX_BUF_SIZE);
+ char* startbuf = buf;
+ int n = 0;
+ char* s = getenv(source);
+ char end = ';';
+ if (s == NULL) {
+ return;
+ }
+ *buf = ';';
+ strncpy(buf + 1, s, PREFIX_BUF_SIZE - 2);
+ while (end != '\0') {
+ startbuf++;
+ while (*(startbuf + n) != ';' && *(startbuf + n) != '\0') {
+ n++;
+ }
+ end = startbuf[n];
+ if (n > 2 && startbuf[0] != '#') {
+ int psize;
+ if (startbuf[n - 1] != '*') {
+ startbuf[n] = '\0';
+ psize = n + 1;
+ }
+ else {
+ psize = n - 1;
+ }
+ addPrefix(startbuf, psize);
+ startbuf += n;
+ n = 0;
+ }
+ }
+}
+
+
+#define BT_DEPTH 10
+
+class GlibcBacktraceProvider {
+private:
+ std::map<void*, RawStackFrame*> cache;
+ /*
+ * Backtrace being returned by glibc backtrace() contains stack frames
+ * belonging to apitrace wrapper module. We count the number of apitrace
+ * functions on the stack to avoid recording these frames.
+ */
+ int numOfNestedFunctions;
+private:
+/*
+ * Parse a stack frame, expecting:
+ * /lib/libc.so.6.1(__libc_start_main+0x50308) [0x2000000000097630]
+ * or
+ * /lib/libc.so.6.1(+0x50308) [0x2000000000097630]
+ * or
+ * /lib/libc.so.6.1() [0x2000000000097630]
+ */
+ RawStackFrame* parseFrame(void* frame, char* frame_symbol) {
+ if (cache.find(frame) == cache.end()) {
+ char* frame_symbol_copy = new char[strlen(frame_symbol) + 1];
+ strcpy(frame_symbol_copy, frame_symbol);
+ RawStackFrame* parsedFrame = new RawStackFrame;
+ char* frame_it = frame_symbol_copy;
+ parsedFrame->module = frame_it;
+ while (true) {
+ switch (*frame_it) {
+ case '(':
+ *frame_it = '\0';
+ frame_it++;
+ if (*frame_it != ')' && *frame_it != '+') {
+ parsedFrame->function = frame_it;
+ while (*frame_it != '+' && *frame_it != ')') {
+ frame_it++;
+ }
+ *frame_it = '\0';
+ frame_it++;
+ }
+ break;
+ case '[':
+ *frame_it = '\0';
+ frame_it++;
+ parsedFrame->offset = frame_it;
+ break;
+ case ']':
+ *frame_it = '\0';
+ cache[frame] = parsedFrame;
+ return parsedFrame;
+ case '\0':
+ cache[frame] = NULL;
+ delete[] frame_symbol_copy;
+ delete[] parsedFrame;
+ return NULL;
+ default:
+ frame_it++;
+ }
+ }
+ }
+ else {
+ return cache[frame];
+ }
+ }
+public:
+ GlibcBacktraceProvider() :
+ numOfNestedFunctions(0) {
+ }
+ std::vector<RawStackFrame> getParsedBacktrace() {
+ std::vector<RawStackFrame> parsedBacktrace;
+ void *array[numOfNestedFunctions + BT_DEPTH];
+ size_t size;
+ char **strings;
+ size_t i;
+ const char* firstModule;
+ size = backtrace(array, numOfNestedFunctions + BT_DEPTH);
+ strings = backtrace_symbols(array, size);
+ for (i = numOfNestedFunctions; i < size; i++) {
+ RawStackFrame* parsedFrame = parseFrame(array[i], strings[i]);
+ if (numOfNestedFunctions == 0) {
+ if (i == 0) {
+ firstModule = parsedFrame->module;
+ }
+ else {
+ if (strcmp(firstModule, parsedFrame->module)) {
+ numOfNestedFunctions = i;
+ free(strings);
+ parsedBacktrace = getParsedBacktrace();
+ numOfNestedFunctions--;
+ return parsedBacktrace;
+ }
+ }
+ } else {
+ if (parsedFrame != NULL) {
+ parsedBacktrace.push_back(*parsedFrame);
+ }
+ }
+ }
+ free(strings);
+ return parsedBacktrace;
+ }
+};
+
+
+std::vector<RawStackFrame> get_backtrace() {
+ static GlibcBacktraceProvider backtraceProvider;
+ return backtraceProvider.getParsedBacktrace();
+}
+
+#endif /* LINUX */
+
+} /* namespace trace */
+
+#endif /* ANDROID or LINUX */
--- /dev/null
+#ifndef _TRACE_BACKTRACE_HPP_
+#define _TRACE_BACKTRACE_HPP_
+
+#include <vector>
+
+#include "trace_model.hpp"
+
+namespace trace {
+
+
+struct RawStackFrame {
+ char* module;
+ char* function;
+ char* filename;
+ char* linenumber;
+ char* offset;
+ RawStackFrame() :
+ module(0),
+ function(0),
+ filename(0),
+ linenumber(0),
+ offset(0)
+ {
+ }
+};
+
+#if defined(ANDROID) or defined(__linux__)
+
+std::vector<RawStackFrame> get_backtrace();
+bool backtrace_is_needed(const char* fname);
+
+#if defined(ANDROID)
+
+#define MAX_BT_FUNC 20
+#define PREFIX_MAX_FUNC_NAME 100
+#define APITRACE_FNAMES_FILE "/data/apitrace.fnames"
+#define APITRACE_FNAMES_SOURCE APITRACE_FNAMES_FILE
+
+#elif defined(__linux__)
+
+#define MAX_BT_FUNC 20
+#define PREFIX_MAX_FUNC_NAME 100
+#define APITRACE_FNAMES_ENV "APITRACE_BT_FUNCTIONS"
+#define APITRACE_FNAMES_SOURCE APITRACE_FNAMES_ENV
+
+#endif
+
+#else /* !__linux__ && !ANDROID */
+
+static inline std::vector<StackFrame> get_backtrace() {
+ return std::vector<StackFrame>();
+}
+
+static inline bool backtrace_is_needed(const char*) {
+ return false;
+}
+
+#endif
+
+} /* namespace trace */
+
+#endif
_visit(r->humanValue);
}
+ void visit(StackFrame *frame) {
+ String* tmp;
+ tmp = frame->module;
+ if (tmp != NULL) {
+ os << tmp->toString() << " ";
+ }
+ tmp = frame->function;
+ if (tmp != NULL) {
+ os << "at " << tmp->toString() << "() ";
+ }
+ tmp = frame->filename;
+ if (tmp != NULL) {
+ os << "at " << tmp->toString();
+ tmp = frame->linenumber;
+ if (tmp != NULL) {
+ os << ":" << tmp->toString() << " ";
+ }
+ }
+ else {
+ tmp = frame->offset;
+ if (tmp != NULL) {
+ os << "[" << tmp->toString() << "]";
+ }
+ }
+ }
+
+ void visit(Backtrace* backtrace) {
+ for (int i = 0; i < backtrace->frames.size(); i ++) {
+ visit(backtrace->frames[i]);
+ os << "\n";
+ }
+ }
+
void visit(Call *call) {
CallFlags callFlags = call->flags;
os << "\n";
+ if (call->backtrace != NULL) {
+ os << bold << red << "Backtrace:\n" << normal;
+ visit(call->backtrace);
+ }
if (callFlags & CALL_FLAG_END_FRAME) {
os << "\n";
}
*
* - version 4:
* - call enter events include thread ID
+ *
+ * - version 5:
+ * - new call detail flag CALL_BACKTRACE
*/
-#define TRACE_VERSION 4
+#define TRACE_VERSION 5
/*
CALL_ARG,
CALL_RET,
CALL_THREAD,
+ CALL_BACKTRACE,
+};
+
+enum CallBacktrace {
+ CALL_BACKTRACE_FRAME = 0,
+ CALL_BACKTRACE_MODULE,
+ CALL_BACKTRACE_FUNCTION,
+ CALL_BACKTRACE_FILENAME,
+ CALL_BACKTRACE_LINENUMBER,
+ CALL_BACKTRACE_OFFSET,
+ CALL_BACKTRACE_END,
};
enum Type {
}
}
+StackFrame::~StackFrame() {
+ if (module != NULL) {
+ delete module;
+ }
+ if (function != NULL) {
+ delete function;
+ }
+ if (filename != NULL) {
+ delete filename;
+ }
+ if (linenumber != NULL) {
+ delete linenumber;
+ }
+ if (offset != NULL) {
+ delete offset;
+ }
+}
+
+Backtrace::~Backtrace() {
+ for (int i = 0; i < frames.size(); i++) {
+ delete frames[i];
+ }
+}
// bool cast
bool Null ::toBool(void) const { return false; }
void Pointer::visit(Visitor &visitor) { visitor.visit(this); }
void Repr ::visit(Visitor &visitor) { visitor.visit(this); }
+void Backtrace::addFrame(StackFrame* frame) {
+ frames.push_back(frame);
+}
void Visitor::visit(Null *) { assert(0); }
void Visitor::visit(Bool *) { assert(0); }
void Visitor::visit(Blob *) { assert(0); }
void Visitor::visit(Pointer *) { assert(0); }
void Visitor::visit(Repr *node) { node->machineValue->visit(*this); }
+void Visitor::visit(Backtrace *) { assert(0); }
+void Visitor::visit(StackFrame *) { assert(0); }
static Null null;
const char *name;
unsigned num_args;
const char **arg_names;
+ bool backtrace;
};
void visit(Visitor &visitor);
};
+class StackFrame {
+public:
+ String* module;
+ String* function;
+ String* filename;
+ String* linenumber;
+ String* offset;
+ StackFrame() :
+ module(NULL),
+ function(NULL),
+ filename(NULL),
+ linenumber(NULL),
+ offset(NULL)
+ {}
+ ~StackFrame();
+};
+
+class Backtrace {
+public:
+ std::vector<StackFrame*> frames;
+ ~Backtrace();
+ void addFrame(StackFrame* frame);
+};
class Visitor
{
virtual void visit(Blob *);
virtual void visit(Pointer *);
virtual void visit(Repr *);
-
+ virtual void visit(Backtrace *);
+ virtual void visit(StackFrame *);
protected:
inline void _visit(Value *value) {
if (value) {
public:
unsigned thread_id;
unsigned no;
- const FunctionSig *sig;
+ FunctionSig *sig;
std::vector<Arg> args;
Value *ret;
CallFlags flags;
+ Backtrace* backtrace;
- Call(const FunctionSig *_sig, const CallFlags &_flags, unsigned _thread_id) :
+ Call(FunctionSig *_sig, const CallFlags &_flags, unsigned _thread_id) :
thread_id(_thread_id),
sig(_sig),
args(_sig->num_args),
ret(0),
- flags(_flags) {
+ flags(_flags),
+ backtrace(0) {
}
~Call();
* between two frames. We won't return this call, but we still need to skip
* over its data.
*/
- const FunctionSig sig = {0, NULL, 0, NULL};
+ FunctionSig sig = {0, NULL, 0, NULL};
call = new Call(&sig, 0, 0);
parse_call_details(call, SCAN);
delete call;
#endif
call->ret = parse_value(mode);
break;
+ case trace::CALL_BACKTRACE:
+#if TRACE_VERBOSE
+ std::cerr << "\tCALL_BACKTRACE\n";
+#endif
+ parse_call_backtrace(call, mode);
+ break;
default:
std::cerr << "error: ("<<call->name()<< ") unknown call detail "
<< c << "\n";
} while(true);
}
+bool Parser::parse_call_backtrace(Call *call, Mode mode) {
+ Backtrace* backtrace = new Backtrace();
+ StackFrame* frame = NULL;
+ do {
+ int c = read_byte();
+ switch (c) {
+ case trace::CALL_BACKTRACE_FRAME:
+ if (frame != NULL) {
+ backtrace->addFrame(frame);
+ }
+ frame = new StackFrame();
+ break;
+ case trace::CALL_BACKTRACE_END:
+ if (frame != NULL) {
+ backtrace->addFrame(frame);
+ }
+ call->backtrace = backtrace;
+ return true;
+ case trace::CALL_BACKTRACE_MODULE:
+ frame->module = static_cast<String*>(parse_value(mode));
+ break;
+ case trace::CALL_BACKTRACE_FUNCTION:
+ frame->function = static_cast<String*>(parse_value(mode));
+ break;
+ case trace::CALL_BACKTRACE_FILENAME:
+ frame->filename = static_cast<String*>(parse_value(mode));
+ break;
+ case trace::CALL_BACKTRACE_LINENUMBER:
+ frame->linenumber = static_cast<String*>(parse_value(mode));
+ break;
+ case trace::CALL_BACKTRACE_OFFSET:
+ frame->offset = static_cast<String*>(parse_value(mode));
+ break;
+ default:
+ std::cerr << "error: ("<< call->name() << ") unknown call backtrace detail "
+ << c << "\n";
+ exit(1);
+ case -1:
+ return false;
+ }
+ } while(true);
+}
/**
* Make adjustments to this particular call flags.
bool parse_call_details(Call *call, Mode mode);
+ bool parse_call_backtrace(Call *call, Mode mode);
+
void adjust_call_flags(Call *call);
void parse_arg(Call *call, Mode mode);
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <vector>
#include "os.hpp"
#include "trace_file.hpp"
#include "trace_writer.hpp"
#include "trace_format.hpp"
-
+#include "trace_backtrace.hpp"
namespace trace {
}
}
-unsigned Writer::beginEnter(const FunctionSig *sig, unsigned thread_id) {
+void Writer::writeBacktrace(std::vector<RawStackFrame> backtrace) {
+
+ for (int i = 0; i < backtrace.size(); i++) {
+ beginStackFrame();
+ if (backtrace[i].module != NULL) {
+ beginStackFrameModule();
+ writeString(backtrace[i].module);
+ endStackFrameModule();
+ }
+ if (backtrace[i].function != NULL) {
+ beginStackFrameFunction();
+ writeString(backtrace[i].function);
+ endStackFrameFunction();
+ }
+ if (backtrace[i].filename != NULL) {
+ beginStackFrameFilename();
+ writeString(backtrace[i].filename);
+ endStackFrameFilename();
+ }
+ if (backtrace[i].linenumber != NULL) {
+ beginStackFrameLinenumber();
+ writeString(backtrace[i].linenumber);
+ endStackFrameLinenumber();
+ }
+ if (backtrace[i].offset != NULL) {
+ beginStackFrameOffset();
+ writeString(backtrace[i].offset);
+ endStackFrameOffset();
+ }
+ endStackFrame();
+ }
+}
+
+void Writer::beginBacktrace(void ) {
+ _writeByte(trace::CALL_BACKTRACE);
+}
+
+void Writer::endBacktrace(void ) {
+ _writeByte(trace::CALL_BACKTRACE_END);
+}
+
+void Writer::beginStackFrame(void ) {
+ _writeByte(trace::CALL_BACKTRACE_FRAME);
+}
+
+void Writer::beginStackFrameModule(void ) {
+ _writeByte(trace::CALL_BACKTRACE_MODULE);
+}
+
+void Writer::beginStackFrameFunction(void ) {
+ _writeByte(trace::CALL_BACKTRACE_FUNCTION);
+}
+
+void Writer::beginStackFrameFilename(void ) {
+ _writeByte(trace::CALL_BACKTRACE_FILENAME);
+}
+
+void Writer::beginStackFrameLinenumber(void ) {
+ _writeByte(trace::CALL_BACKTRACE_LINENUMBER);
+}
+
+void Writer::beginStackFrameOffset(void ) {
+ _writeByte(trace::CALL_BACKTRACE_OFFSET);
+}
+
+unsigned Writer::beginEnter(FunctionSig *sig, unsigned thread_id) {
_writeByte(trace::EVENT_ENTER);
_writeUInt(thread_id);
_writeUInt(sig->id);
if (!lookup(functions, sig->id)) {
+ sig->backtrace = backtrace_is_needed(sig->name);
_writeString(sig->name);
_writeUInt(sig->num_args);
for (unsigned i = 0; i < sig->num_args; ++i) {
#include <vector>
#include "trace_model.hpp"
-
+#include "trace_backtrace.hpp"
namespace trace {
class File;
bool open(const char *filename);
void close(void);
- unsigned beginEnter(const FunctionSig *sig, unsigned thread_id);
+ void writeBacktrace(std::vector<RawStackFrame> backtrace);
+ void beginBacktrace(void);
+ void endBacktrace(void);
+ void beginStackFrame(void);
+ inline void endStackFrame(void) {}
+ void beginStackFrameModule(void);
+ inline void endStackFrameModule(void) {}
+ void beginStackFrameFunction(void);
+ inline void endStackFrameFunction(void) {}
+ void beginStackFrameFilename(void);
+ inline void endStackFrameFilename(void) {}
+ void beginStackFrameLinenumber(void);
+ inline void endStackFrameLinenumber(void) {}
+ void beginStackFrameOffset(void);
+ inline void endStackFrameOffset(void) {}
+
+ unsigned beginEnter(FunctionSig *sig, unsigned thread_id);
void endEnter(void);
void beginLeave(unsigned call);
#include "trace_file.hpp"
#include "trace_writer_local.hpp"
#include "trace_format.hpp"
+#include "trace_backtrace.hpp"
namespace trace {
static const char *memcpy_args[3] = {"dest", "src", "n"};
-const FunctionSig memcpy_sig = {0, "memcpy", 3, memcpy_args};
+FunctionSig memcpy_sig = {0, "memcpy", 3, memcpy_args, false};
static const char *malloc_args[1] = {"size"};
-const FunctionSig malloc_sig = {1, "malloc", 1, malloc_args};
+FunctionSig malloc_sig = {1, "malloc", 1, malloc_args, false};
static const char *free_args[1] = {"ptr"};
-const FunctionSig free_sig = {2, "free", 1, free_args};
+FunctionSig free_sig = {2, "free", 1, free_args, false};
static const char *realloc_args[2] = {"ptr", "size"};
-const FunctionSig realloc_sig = {3, "realloc", 2, realloc_args};
+FunctionSig realloc_sig = {3, "realloc", 2, realloc_args, false};
static void exceptionCallback(void)
static OS_THREAD_SPECIFIC_PTR(void)
thread_num;
-unsigned LocalWriter::beginEnter(const FunctionSig *sig) {
+unsigned LocalWriter::beginEnter(FunctionSig *sig) {
mutex.lock();
++acquired;
assert(this_thread_num);
unsigned thread_id = this_thread_num - 1;
- return Writer::beginEnter(sig, thread_id);
+ unsigned call_no = Writer::beginEnter(sig, thread_id);
+ if (sig->backtrace) {
+ std::vector<RawStackFrame> backtrace = get_backtrace();
+ beginBacktrace();
+ writeBacktrace(backtrace);
+ endBacktrace();
+ }
+ return call_no;
}
void LocalWriter::endEnter(void) {
namespace trace {
- extern const FunctionSig memcpy_sig;
- extern const FunctionSig malloc_sig;
- extern const FunctionSig free_sig;
- extern const FunctionSig realloc_sig;
+ extern FunctionSig memcpy_sig;
+ extern FunctionSig malloc_sig;
+ extern FunctionSig free_sig;
+ extern FunctionSig realloc_sig;
/**
* A specialized Writer class, mean to trace the current process.
/**
* It will acquire the mutex.
*/
- unsigned beginEnter(const FunctionSig *sig);
-
+ unsigned beginEnter(FunctionSig *sig);
+
/**
* It will release the mutex.
*/
writer.endRepr();
}
+ void visit(StackFrame* frame) {
+ writer.beginStackFrame();
+ if (frame->module != NULL) {
+ writer.beginStackFrameModule();
+ _visit(frame->module);
+ writer.endStackFrameModule();
+ }
+ if (frame->function != NULL) {
+ writer.beginStackFrameFunction();
+ _visit(frame->function);
+ writer.endStackFrameFunction();
+ }
+ if (frame->filename != NULL) {
+ writer.beginStackFrameFilename();
+ _visit(frame->filename);
+ writer.endStackFrameFilename();
+ }
+ if (frame->linenumber != NULL) {
+ writer.beginStackFrameLinenumber();
+ _visit(frame->linenumber);
+ writer.endStackFrameLinenumber();
+ }
+ if (frame->offset != NULL) {
+ writer.beginStackFrameOffset();
+ _visit(frame->offset);
+ writer.endStackFrameOffset();
+ }
+ writer.endStackFrame();
+ }
+
+ void visit(Backtrace * backtrace) {
+ writer.beginBacktrace();
+ for (int i =0; i < backtrace->frames.size(); i++) {
+ visit(backtrace->frames[i]);
+ }
+ writer.endBacktrace();
+ }
+
void visit(Call *call) {
unsigned call_no = writer.beginEnter(call->sig, call->thread_id);
+ if (call->backtrace != NULL) {
+ visit(call->backtrace);
+ }
for (unsigned i = 0; i < call->args.size(); ++i) {
if (call->args[i].value) {
writer.beginArg(i);
}
m_argValues.squeeze();
m_flags = call->flags;
+ if (call->backtrace != NULL) {
+ QString qbacktrace;
+ for (int i = 0; i < call->backtrace->frames.size(); i++) {
+ trace::StackFrame* frame = call->backtrace->frames[i];
+ trace::String* tmp;
+ tmp = frame->module;
+ if (tmp != NULL) {
+ qbacktrace += QString("%1 ").arg(tmp->toString());
+ }
+ tmp = frame->function;
+ if (tmp != NULL) {
+ qbacktrace += QString("at %1() ").arg(tmp->toString());
+ }
+ tmp = frame->filename;
+ if (tmp != NULL) {
+ qbacktrace += QString("at %1").arg(tmp->toString());
+ tmp = frame->linenumber;
+ if (tmp != NULL) {
+ qbacktrace += QString(":%1 ").arg(tmp->toString());
+ }
+ }
+ else {
+ tmp = frame->offset;
+ if (tmp != NULL) {
+ qbacktrace += QString("[%1]").arg(tmp->toString());
+ }
+ }
+ qbacktrace += "\n";
+ }
+ this->setBacktrace(qbacktrace);
+ }
}
ApiTraceCall::~ApiTraceCall()
return m_binaryDataIndex;
}
+QString ApiTraceCall::backtrace() const
+{
+ return m_backtrace;
+}
+
+void ApiTraceCall::setBacktrace(QString backtrace)
+{
+ m_backtrace = backtrace;
+}
+
QStaticText ApiTraceCall::staticText() const
{
if (m_staticText && !m_staticText->text().isEmpty())
int numChildren() const;
bool hasBinaryData() const;
int binaryDataIndex() const;
+
+ QString backtrace() const;
+ void setBacktrace(QString backtrace);
private:
int m_index;
ApiTraceCallSignature *m_signature;
QString m_error;
+ QString m_backtrace;
+
mutable QString m_richText;
mutable QString m_searchText;
};
if (event && event->type() == ApiTraceEvent::Call) {
ApiTraceCall *call = static_cast<ApiTraceCall*>(event);
+ if (!call->backtrace().isNull()) {
+ m_ui.backtraceBrowser->setText(call->backtrace());
+ m_ui.backtraceDock->show();
+ }
+ else {
+ m_ui.backtraceDock->hide();
+ }
m_ui.detailsDock->setWindowTitle(
tr("Details View. Frame %1, Call %2")
.arg(call->parentFrame() ? call->parentFrame()->number : 0)
m_selectedEvent = 0;
}
m_ui.detailsDock->hide();
+ m_ui.backtraceDock->hide();
m_ui.vertexDataDock->hide();
}
if (m_selectedEvent && m_selectedEvent->hasState()) {
m_argsEditor = new ArgumentsEditor(this);
m_ui.detailsDock->hide();
+ m_ui.backtraceDock->hide();
m_ui.errorsDock->hide();
m_ui.vertexDataDock->hide();
m_ui.stateDock->hide();
tabifyDockWidget(m_ui.stateDock, m_ui.vertexDataDock);
tabifyDockWidget(m_ui.detailsDock, m_ui.errorsDock);
+ tabifyDockWidget(m_ui.detailsDock, m_ui.backtraceDock);
m_ui.surfacesTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
<layout class="QVBoxLayout" name="verticalLayout_4">
<item>
<widget class="QTreeWidget" name="errorsTreeWidget">
+ <property name="layoutDirection">
+ <enum>Qt::LeftToRight</enum>
+ </property>
<column>
<property name="text">
<string>Index</string>
</layout>
</widget>
</widget>
+ <widget class="QDockWidget" name="backtraceDock">
+ <property name="windowTitle">
+ <string>Backtrace</string>
+ </property>
+ <attribute name="dockWidgetArea">
+ <number>8</number>
+ </attribute>
+ <widget class="QWidget" name="dockWidgetContents">
+ <layout class="QHBoxLayout" name="horizontalLayout">
+ <item>
+ <widget class="QTextBrowser" name="backtraceBrowser"/>
+ </item>
+ </layout>
+ </widget>
+ </widget>
<action name="actionExit">
<property name="text">
<string>Exit</string>
<zorder>stateDock</zorder>
<zorder>vertexDataDock</zorder>
<zorder>errorsDock</zorder>
+ <zorder>backtraceDock</zorder>
</widget>
<customwidgets>
<customwidget>
# Emit a fake function
print ' {'
- print ' static const trace::FunctionSig &_sig = %s ? _glEnableClientState_sig : _glDisableClientState_sig;' % flag_name
+ print ' static trace::FunctionSig &_sig = %s ? _glEnableClientState_sig : _glDisableClientState_sig;' % flag_name
print ' unsigned _call = trace::localWriter.beginEnter(&_sig);'
print ' trace::localWriter.beginArg(0);'
self.serializeValue(glapi.GLenum, enable_name)
print 'static const char * _%s_args[%u] = {%s};' % (function.name, len(function.args), ', '.join(['"%s"' % arg.name for arg in function.args]))
else:
print 'static const char ** _%s_args = NULL;' % (function.name,)
- print 'static const trace::FunctionSig _%s_sig = {%u, "%s", %u, _%s_args};' % (function.name, self.getFunctionSigId(), function.name, len(function.args), function.name)
+ print 'static trace::FunctionSig _%s_sig = {%u, "%s", %u, _%s_args};' % (function.name, self.getFunctionSigId(), function.name, len(function.args), function.name)
print
def getFunctionSigId(self):
assert not method.internal
print ' static const char * _args[%u] = {%s};' % (len(method.args) + 1, ', '.join(['"this"'] + ['"%s"' % arg.name for arg in method.args]))
- print ' static const trace::FunctionSig _sig = {%u, "%s", %u, _args};' % (self.getFunctionSigId(), interface.name + '::' + method.name, len(method.args) + 1)
+ print ' static trace::FunctionSig _sig = {%u, "%s", %u, _args};' % (self.getFunctionSigId(), interface.name + '::' + method.name, len(method.args) + 1)
print ' %s *_this = static_cast<%s *>(m_pInstance);' % (base, base)
projects / apitrace / commitdiff