Emit symbol maps for compiled code for use by the Linux perf tool.

runtime/bin/main.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
@@ skipping 17 matching lines @@
 
 // Global state that stores the original working directory..
 static const char* original_working_directory = NULL;
 
 
 // Global state that stores the import URL map specified on the
 // command line.
 static CommandLineOptions* import_map_options = NULL;
 
 
+// Global state that indicates whether perf_events symbol information
+// is to be generated or not.
+static File* perf_events_symbols_file = NULL;
+
+
 // Global state that indicates whether pprof symbol information is
 // to be generated or not.
 static const char* generate_pprof_symbols_filename = NULL;
 
 
 // Global state that stores a file name for flow graph debugging output.
 // NULL if no output is generated.
 static File* flow_graph_file = NULL;
 
 // Global state that indicates whether there is a debug breakpoint.
@@ skipping 73 matching lines @@
   if (debug_port == 0) {
     fprintf(stderr, "unrecognized --debug option syntax. "
                     "Use --debug[:<port number>]\n");
     return;
   }
   breakpoint_at = "main";
   start_debugger = true;
 }
 
 
+static void ProcessPerfEventsOption(const char* option) {
+  ASSERT(option != NULL);
+  if (perf_events_symbols_file == NULL) {
+    // TODO(cshapiro): eliminate the #ifdef by moving this code to a
+    // Linux specific source file.
+#if defined(TARGET_OS_LINUX)
+    const char* format = "/tmp/perf-%ld.map";
+    intptr_t pid = Process::CurrentProcessId();
+    intptr_t len = snprintf(NULL, 0, format, pid);
+    char* filename = new char[len + 1];
+    snprintf(filename, len + 1, format, pid);
+    perf_events_symbols_file = File::Open(filename, File::kWriteTruncate);
+    ASSERT(perf_events_symbols_file != NULL);
+    delete[] filename;
+#endif
+  }
+}
+
+
 static void ProcessPprofOption(const char* filename) {
   ASSERT(filename != NULL);
   generate_pprof_symbols_filename = filename;
 }
 
 
 static void ProcessFlowGraphOption(const char* flowgraph_option) {
   ASSERT(flowgraph_option != NULL);
   flow_graph_file = File::Open("flowgraph.cfg", File::kWriteTruncate);
   ASSERT(flow_graph_file != NULL);
 }
 
 
 static void ProcessImportMapOption(const char* map) {
   ASSERT(map != NULL);
   import_map_options->AddArgument(map);
 }
 
 
 static struct {
   const char* option_name;
   void (*process)(const char* option);
 } main_options[] = {
   { "--break_at=", ProcessBreakpointOption },
   { "--compile_all", ProcessCompileAllOption },
   { "--debug", ProcessDebugOption },
+  { "--generate_perf_events_symbols", ProcessPerfEventsOption },
   { "--generate_pprof_symbols=", ProcessPprofOption },
   { "--import_map=", ProcessImportMapOption },
   { "--package-root=", ProcessPackageRootOption },
   { "--generate_flow_graph", ProcessFlowGraphOption },
   { NULL, NULL }
 };
 
 
 static bool ProcessMainOptions(const char* option) {
   int i = 0;
   const char* name = main_options[0].option_name;
   while (name != NULL) {
     int length = strlen(name);
     if (strncmp(option, name, length) == 0) {
       main_options[i].process(option + length);
       return true;
     }
     i += 1;
     name = main_options[i].option_name;
   }
   return false;
 }
 
 
+static void WriteToPerfEventsFile(const char* buffer, int64_t num_bytes) {
+  ASSERT(perf_events_symbols_file != NULL);
+  perf_events_symbols_file->WriteFully(buffer, num_bytes);
+}
+
+
 static void WriteToFlowGraphFile(const char* buffer, int64_t num_bytes) {
   ASSERT(flow_graph_file != NULL);
   flow_graph_file->WriteFully(buffer, num_bytes);
 }
 
 
 // Parse out the command line arguments. Returns -1 if the arguments
 // are incorrect, 0 otherwise.
 static int ParseArguments(int argc,
                           char** argv,
@@ skipping 19 matching lines @@
       const char* kPrintFlags1 = "--print-flags";
       const char* kPrintFlags2 = "--print_flags";
       if ((strncmp(argv[i], kPrintFlags1, strlen(kPrintFlags1)) == 0) ||
           (strncmp(argv[i], kPrintFlags2, strlen(kPrintFlags2)) == 0)) {
         *print_flags_seen = true;
       }
       vm_options->AddArgument(argv[i]);
       i++;
     }
   }
+
+  if (perf_events_symbols_file != NULL) {
+    Dart_InitPerfEventsSupport(&WriteToPerfEventsFile);
+  }
+
   if (generate_pprof_symbols_filename != NULL) {
     Dart_InitPprofSupport();
   }
 
   if (flow_graph_file != NULL) {
     Dart_InitFlowGraphPrinting(&WriteToFlowGraphFile);
   }
 
   // Get the script name.
   if (i < argc) {
@@ skipping 587 matching lines @@
   DumpPprofSymbolInfo();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   free(const_cast<char*>(original_working_directory));
 
   return 0;
 }