Automatically run file command on remote connection to the target if NaCl manifest was provided by …

gdb/nacl-manifest.c

 /* Handle Native Client manifest files.
 
    Copyright (C) 2011 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 
 #include "command.h"
 #include "completer.h"
+#include "exec.h"
+#include "observer.h"
 #include "readline/readline.h"
 #include "solib.h"
+#include "symfile.h"
 
 #include <ctype.h>
 #include <stdio.h>
 #include <string.h>
 
 #define MANIFEST_MAX_NESTING 4
 
 #define MANIFEST_MAX_STRING_SIZE 256
 
 struct file_list
@@ skipping 114 matching lines @@
   r->members[r->nesting] = member;
   ++r->nesting;
 }
 
 static void
 json_on_end_member (struct json_manifest_reader *r, const char *member)
 {
   --r->nesting;
 }
 
+static void
+append_dir_name (struct json_manifest_reader *r,
+                 char *full_path,
+                 int max_path_size,
+                 char *name)
+{
+  full_path[0] = '\0';
+  if (r->dirname)
+    {
+      if (strlen (r->dirname) + strlen (SLASH_STRING) >= max_path_size)
+        error (_("Mapped file name in manifest is too long."));
+      strcpy (full_path, r->dirname);
+      strcat (full_path, SLASH_STRING);
+    }
+  if (strlen (full_path) + strlen (name) >= max_path_size)
+    error (_("Mapped file name in manifest is too long."));
+  strcat (full_path, name);
+}
+
 static struct file_list *
 json_append_file_list (struct json_manifest_reader *r,
                        struct file_list **nacl_file_list,
                        const char *original_name,
                        const char *name)
 {
   struct file_list *curr = XZALLOC (struct file_list);
 
   if (strlen(original_name) >= MANIFEST_MAX_STRING_SIZE)
     error (_("Original file name in manifest is too long."));
   strcpy (curr->original_name, original_name);
-
-  if (r->dirname)
-    {
-      strcpy (curr->name, r->dirname);
-      if (strlen(curr->name) + strlen(SLASH_STRING) >= MANIFEST_MAX_STRING_SIZE)
-        error (_("Mapped file name in manifest is too long."));
-      strcat (curr->name, SLASH_STRING);
-    }
-  if (strlen(curr->name) + strlen(name) >= MANIFEST_MAX_STRING_SIZE)
-    error (_("Mapped file name in manifest is too long."));
-  strcat (curr->name, name);
+  append_dir_name (r, curr->name, MANIFEST_MAX_STRING_SIZE, name);
 
   curr->next = *nacl_file_list;
   *nacl_file_list = curr;
   return curr;
 }
 
 static void
 json_on_string_value (struct json_manifest_reader *r, const char *value)
 {
   if (r->nesting == 3 &&
       strcmp(r->members[0], "program") == 0 &&
       strcmp(r->members[2], "url") == 0)
     {
       /* We'll xfree nacl_program_filename_* in nacl_manifest_free.  */
       if (strcmp (r->members[1], "x86-32") == 0)
-        nacl_program_filename_32 = xstrdup (value);
+        {
+          nacl_program_filename_32 = malloc (MANIFEST_MAX_STRING_SIZE);
+          append_dir_name (r, nacl_program_filename_32,
+                           MANIFEST_MAX_STRING_SIZE, value);
+        }
       else if (strcmp (r->members[1], "x86-64") == 0)
-        nacl_program_filename_64 = xstrdup (value);
+        {
+          nacl_program_filename_64 = malloc (MANIFEST_MAX_STRING_SIZE);
+          append_dir_name (r, nacl_program_filename_64,
+                           MANIFEST_MAX_STRING_SIZE, value);
+        }
     }
   else if (r->nesting == 4 &&
            strcmp (r->members[0], "files") == 0 &&
            strcmp (r->members[3], "url") == 0)
     {
       if (strcmp(r->members[2], "x86-32") == 0)
         json_append_file_list(r, &nacl_file_list_32, r->members[1], value);
       else if (strcmp(r->members[2], "x86-64") == 0)
         json_append_file_list(r, &nacl_file_list_64, r->members[1], value);
     }
@@ skipping 112 matching lines @@
 {
   if (args)
     {
       xfree (nacl_irt_filename);
       nacl_irt_filename = tilde_expand (args);
 
       solib_add (NULL, from_tty, NULL, 1);
     }
 }
 
+static struct observer *about_to_proceed_observer = NULL;
+
+static void
+about_to_proceed_hook ()
+{
+  if (exec_bfd == NULL)
+    {
+      const char *filename = nacl_manifest_find ("NaClMain");
+      exec_file_attach (filename, 0);
+      symbol_file_add (filename, SYMFILE_MAINLINE, NULL, 0);
+    }
+}
+
 static void
 nacl_manifest_command (char *args, int from_tty)
 {
   if (args)
     {
       char *manifest_filename;
       struct cleanup *old_chain;
       struct json_manifest_reader r = { 0 };
 
       manifest_filename = tilde_expand (args);
       old_chain = make_cleanup (xfree, manifest_filename);
 
       r.file = fopen (manifest_filename, "r");
       if (!r.file)
         perror_with_name (manifest_filename);
       make_cleanup_fclose (r.file);
 
       r.dirname = ldirname (manifest_filename);
       make_cleanup (xfree, r.dirname);
 
       /* TODO: Kill existing manifest only if new one parsed OK!  */
       nacl_manifest_free ();
       json_parse_value (&r);
 
       solib_add (NULL, from_tty, NULL, 1);
 
+      if (about_to_proceed_observer == NULL)
+        {
+          about_to_proceed_observer
+            = observer_attach_about_to_proceed (about_to_proceed_hook);
+        }
+
       do_cleanups(old_chain);
     }
 }
 
 void
 _initialize_nacl_manifest (void)
 {
   struct cmd_list_element *c;
 
   c = add_com ("nacl-irt", class_files, nacl_irt_command,
                _("Use FILE as Native Client IRT to be debugged."));
   set_cmd_completer (c, filename_completer);
 
   c = add_com ("nacl-manifest", class_files, nacl_manifest_command,
                _("Use FILE as Native Client manifest for the program"
                  " to be debugged."));
   set_cmd_completer (c, filename_completer);
 }