auto import from //depot/cupcake/@135843
diff --git a/emulator/qtools/q2dm.cpp b/emulator/qtools/q2dm.cpp
new file mode 100644
index 0000000..7f987dc
--- /dev/null
+++ b/emulator/qtools/q2dm.cpp
@@ -0,0 +1,275 @@
+// Copyright 2006 The Android Open Source Project
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <assert.h>
+#include "trace_reader.h"
+#include "bitvector.h"
+#include "parse_options.h"
+#include "dmtrace.h"
+#include "armdis.h"
+
+struct symbol {
+ uint32_t id;
+};
+
+typedef TraceReader<symbol> TraceReaderType;
+
+#include "parse_options-inl.h"
+#include "callstack.h"
+
+DmTrace *dmtrace;
+
+class MyFrame : public StackFrame<symbol_type> {
+ public:
+ void push(int stackLevel, uint64_t time, CallStackBase *base);
+ void pop(int stackLevel, uint64_t time, CallStackBase *base);
+};
+
+typedef CallStack<MyFrame> CallStackType;
+
+static const int kNumStackFrames = 500;
+static const int kMaxThreads = (32 * 1024);
+uint64_t thread_time[kMaxThreads];
+
+class FunctionStack {
+ public:
+ FunctionStack() {
+ top = 0;
+ }
+ void push(symbol_type *sym) {
+ if (top >= kNumStackFrames)
+ return;
+ frames[top] = sym;
+ top += 1;
+ }
+
+ symbol_type* pop() {
+ if (top <= 0) {
+ return NULL;
+ }
+ top -= 1;
+ return frames[top];
+ }
+
+ void showStack() {
+ fprintf(stderr, "top %d\n", top);
+ for (int ii = 0; ii < top; ii++) {
+ fprintf(stderr, " %d: %s\n", ii, frames[ii]->name);
+ }
+ }
+
+ private:
+ int top;
+ symbol_type *frames[kNumStackFrames];
+};
+
+FunctionStack *dmtrace_stack[kMaxThreads];
+
+void MyFrame::push(int stackLevel, uint64_t time, CallStackBase *base)
+{
+ int pid = base->getId();
+ CallStackType *stack = (CallStackType *) base;
+
+#if 0
+ fprintf(stderr, "native push t %llu p %d s %d fid %d 0x%x %s\n",
+ stack->getGlobalTime(time), pid, stackLevel,
+ function->id, function->addr, function->name);
+#endif
+
+ FunctionStack *fstack = dmtrace_stack[pid];
+ if (fstack == NULL) {
+ fstack = new FunctionStack();
+ dmtrace_stack[pid] = fstack;
+ }
+
+ fstack->push(function);
+ thread_time[pid] = time;
+ dmtrace->addFunctionEntry(function->id, time, pid);
+}
+
+void MyFrame::pop(int stackLevel, uint64_t time, CallStackBase *base)
+{
+ int pid = base->getId();
+ CallStackType *stack = (CallStackType *) base;
+
+#if 0
+ fprintf(stderr, "native pop t %llu p %d s %d fid %d 0x%x %s\n",
+ stack->getGlobalTime(time), pid, stackLevel,
+ function->id, function->addr, function->name);
+#endif
+
+ FunctionStack *fstack = dmtrace_stack[pid];
+ if (fstack == NULL) {
+ fstack = new FunctionStack();
+ dmtrace_stack[pid] = fstack;
+ }
+
+ symbol_type *sym = fstack->pop();
+ if (sym != NULL && sym != function) {
+ fprintf(stderr, "Error: q2dm function mismatch at time %llu pid %d sym %s\n",
+ stack->getGlobalTime(time), pid, sym->name);
+ fstack->showStack();
+ exit(1);
+ }
+
+ thread_time[pid] = time;
+ dmtrace->addFunctionExit(function->id, time, pid);
+}
+
+uint32_t nextFunctionId = 4;
+CallStackType *stacks[kMaxThreads];
+
+void Usage(const char *program)
+{
+ fprintf(stderr, "Usage: %s [options] trace_name elf_file dmtrace_name\n",
+ program);
+ OptionsUsage();
+}
+
+int main(int argc, char **argv)
+{
+ bool useKernelStack = true;
+
+ ParseOptions(argc, argv);
+ if (argc - optind != 3) {
+ Usage(argv[0]);
+ exit(1);
+ }
+
+ char *qemu_trace_file = argv[optind++];
+ char *elf_file = argv[optind++];
+ char *dmtrace_file = argv[optind++];
+ TraceReaderType *trace = new TraceReaderType;
+ trace->Open(qemu_trace_file);
+ trace->SetDemangle(demangle);
+ trace->ReadKernelSymbols(elf_file);
+ trace->SetRoot(root);
+ TraceHeader *qheader = trace->GetHeader();
+ uint64_t startTime = qheader->start_sec;
+ startTime = (startTime << 32) | qheader->start_usec;
+ int kernelPid = qheader->first_unused_pid;
+
+ dmtrace = new DmTrace;
+ dmtrace->open(dmtrace_file, startTime);
+
+ bool inKernel = false;
+ CallStackType *kernelStack = NULL;
+ if (useKernelStack) {
+ // Create a fake kernel thread stack where we will put all the kernel
+ // code.
+ kernelStack = new CallStackType(kernelPid, kNumStackFrames, trace);
+ dmtrace->addThread(kernelPid, "(kernel)");
+ }
+
+ CallStackType *prevStack = NULL;
+ BBEvent event;
+ while (1) {
+ BBEvent ignored;
+ symbol_type *function;
+
+ if (GetNextValidEvent(trace, &event, &ignored, &function))
+ break;
+ if (event.bb_num == 0)
+ break;
+#if 0
+ fprintf(stderr, "event t %llu p %d %s\n",
+ event.time, event.pid, function->name);
+#endif
+
+ CallStackType *pStack;
+ if (useKernelStack) {
+ uint32_t flags = function->region->flags;
+ uint32_t region_mask = region_type::kIsKernelRegion
+ | region_type::kIsUserMappedRegion;
+ if ((flags & region_mask) == region_type::kIsKernelRegion) {
+ // Use the kernel stack
+ pStack = kernelStack;
+ inKernel = true;
+ } else {
+ // If we were just in the kernel then pop off all of the
+ // stack frames for the kernel thread.
+ if (inKernel == true) {
+ inKernel = false;
+ kernelStack->popAll(event.time);
+ }
+
+ // Get the stack for the current thread
+ pStack = stacks[event.pid];
+ }
+ } else {
+ // Get the stack for the current thread
+ pStack = stacks[event.pid];
+ }
+
+ // If the stack does not exist, then allocate a new one.
+ if (pStack == NULL) {
+ pStack = new CallStackType(event.pid, kNumStackFrames, trace);
+ stacks[event.pid] = pStack;
+ char *name = trace->GetProcessName(event.pid);
+ dmtrace->addThread(event.pid, name);
+ }
+
+ if (prevStack != pStack) {
+ pStack->threadStart(event.time);
+ if (prevStack)
+ prevStack->threadStop(event.time);
+ }
+ prevStack = pStack;
+
+ // If we have never seen this function before, then add it to the
+ // list of known functions.
+ if (function->id == 0) {
+ function->id = nextFunctionId;
+ nextFunctionId += 4;
+ uint32_t flags = function->region->flags;
+ const char *name = function->name;
+ if (flags & region_type::kIsKernelRegion) {
+ // To distinguish kernel function names from user library
+ // names, add a marker to the name.
+ int len = strlen(name) + strlen(" [kernel]") + 1;
+ char *kernelName = new char[len];
+ strcpy(kernelName, name);
+ strcat(kernelName, " [kernel]");
+ name = kernelName;
+ }
+ dmtrace->parseAndAddFunction(function->id, name);
+ }
+
+ // Update the stack
+ pStack->updateStack(&event, function);
+ }
+
+ if (prevStack == NULL) {
+ fprintf(stderr, "Error: no events in trace.\n");
+ exit(1);
+ }
+ prevStack->threadStop(event.time);
+ for (int ii = 0; ii < kMaxThreads; ++ii) {
+ if (stacks[ii]) {
+ stacks[ii]->threadStart(event.time);
+ stacks[ii]->popAll(event.time);
+ }
+ }
+ if (useKernelStack) {
+ kernelStack->popAll(event.time);
+ }
+
+ // Read the pid events to find the names of the processes
+ while (1) {
+ PidEvent pid_event;
+ if (trace->ReadPidEvent(&pid_event))
+ break;
+ if (pid_event.rec_type == kPidName) {
+ dmtrace->updateName(pid_event.pid, pid_event.path);
+ }
+ }
+
+
+ dmtrace->close();
+ delete dmtrace;
+ delete trace;
+ return 0;
+}