diff --git a/gdb/amd64-linux-tdep.c b/gdb/amd64-linux-tdep.c
index 7fe92d1..dd78f3a 100644
--- a/gdb/amd64-linux-tdep.c
+++ b/gdb/amd64-linux-tdep.c
@@ -1535,6 +1535,14 @@
   tdep->i386_syscall_record = amd64_linux_syscall_record;
 }
 
+void
+amd64_linux_init_gregset (struct gdbarch_tdep *tdep)
+{
+  tdep->gregset_reg_offset = amd64_linux_gregset_reg_offset;
+  tdep->gregset_num_regs = ARRAY_SIZE (amd64_linux_gregset_reg_offset);
+  tdep->sizeof_gregset = 27 * 8;
+}
+
 static void
 amd64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 {
@@ -1546,10 +1554,7 @@
 
   gdb_assert (tdesc_data);
 
-  tdep->gregset_reg_offset = amd64_linux_gregset_reg_offset;
-  tdep->gregset_num_regs = ARRAY_SIZE (amd64_linux_gregset_reg_offset);
-  tdep->sizeof_gregset = 27 * 8;
-
+  amd64_linux_init_gregset (tdep);
   amd64_init_abi (info, gdbarch);
 
   /* Reserve a number for orig_rax.  */
diff --git a/gdb/amd64-linux-tdep.h b/gdb/amd64-linux-tdep.h
index 6e85a5b..ed54dfb 100644
--- a/gdb/amd64-linux-tdep.h
+++ b/gdb/amd64-linux-tdep.h
@@ -311,4 +311,6 @@
   amd64_sys_move_pages = 279,
 };
 
+extern void amd64_linux_init_gregset (struct gdbarch_tdep *tdep);
+
 #endif /* amd64-linux-tdep.h */
diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c
index 19968fc..6a2af29 100644
--- a/gdb/amd64-tdep.c
+++ b/gdb/amd64-tdep.c
@@ -2062,6 +2062,75 @@
   return min (pc + offset + 2, current_pc);
 }
 
+/* Check whether it is mov %ebp,%reg instruction.  The function returns the
+   size of instruction or zero if it is not recognized.  Fills reg with the
+   destination register number.  */
+static int
+amd64_is_mov_rbp_reg(gdb_byte* op, int* reg)
+{
+  int cur = 0;
+  *reg = 0;
+  /* [0x40] 0x89 0xe8  mov %ebp, %eax  */
+  if (op[cur] == 0x40 || op[cur] == 0x41)
+    {
+      cur++;
+      *reg += (op[cur] & 1) * 8;
+    }
+  if (op[cur] == 0x89 && (op[cur + 1] & 0xf8) == 0xe8)
+    {
+      *reg += op[cur + 1] & 7;
+      return cur + 2;
+    }
+  cur = 0;
+  *reg = 0;
+  /* [0x40] 0x8b 0xc5  mov %ebp, %eax  */
+  if (op[cur] == 0x40 || op[cur] == 0x44)
+    {
+      *reg += (op[cur] & 4) * 2;
+      cur++;
+    }
+  if (op[cur] == 0x8b && (op[cur + 1] & 0xc7) == 0xc5)
+    {
+      reg += (op[cur + 1] >> 3) & 7;
+      return cur + 2;
+    }
+  *reg = 0;
+  return 0;
+}
+
+/* Check whether it is push %rbp instruction or equivalent sequence
+   mov %ebp, %reg // push %reg.  Returns size of the instruction or zero
+   if it is not recognized.  */
+static int
+amd64_is_push_rbp(CORE_ADDR pc)
+{
+  int cur = 0;
+  int reg = 0;
+  int reg_push = 0;
+  gdb_byte op[5];
+  if (target_read_code(pc, op, 5) != 0)
+    return 0;
+  /* 55  push %rbp  */
+  if (op[0] == 0x55)
+    return 1;
+  cur = amd64_is_mov_rbp_reg(op, &reg);
+  if (cur == 0)
+    return 0;
+  /* Recognize push %reg instruction. */
+  if (op[cur] == 0x40 || op[cur] == 0x41)
+    {
+      reg_push += (op[cur] & 1) * 8;
+      cur++;
+    }
+  if ((op[cur] & 0xf8) == 0x50)
+    {
+      reg_push += op[cur] & 7;
+      if (reg == reg_push)
+	return cur + 1;
+    }
+  return 0;
+}
+
 /* Do a limited analysis of the prologue at PC and update CACHE
    accordingly.  Bail out early if CURRENT_PC is reached.  Return the
    address where the analysis stopped.
@@ -2094,7 +2163,7 @@
   static const gdb_byte mov_esp_ebp_2[2] = { 0x8b, 0xec };
 
   gdb_byte buf[3];
-  gdb_byte op;
+  int push_rbp_size;
 
   if (current_pc <= pc)
     return current_pc;
@@ -2104,20 +2173,22 @@
   else
     pc = amd64_analyze_stack_align (pc, current_pc, cache);
 
-  op = read_code_unsigned_integer (pc, 1, byte_order);
+  push_rbp_size = amd64_is_push_rbp(pc);
 
-  if (op == 0x55)		/* pushq %rbp */
+  if (push_rbp_size)		/* pushq %rbp */
     {
       /* Take into account that we've executed the `pushq %rbp' that
          starts this instruction sequence.  */
       cache->saved_regs[AMD64_RBP_REGNUM] = 0;
       cache->sp_offset += 8;
 
+      pc += push_rbp_size;
+
       /* If that's all, return now.  */
-      if (current_pc <= pc + 1)
+      if (current_pc <= pc)
         return current_pc;
 
-      read_code (pc + 1, buf, 3);
+      read_code (pc, buf, 3);
 
       /* Check for `movq %rsp, %rbp'.  */
       if (memcmp (buf, mov_rsp_rbp_1, 3) == 0
@@ -2125,7 +2196,7 @@
 	{
 	  /* OK, we actually have a frame.  */
 	  cache->frameless_p = 0;
-	  return pc + 4;
+	  return pc + 3;
 	}
 
       /* For X32, also check for `movq %esp, %ebp'.  */
@@ -2136,11 +2207,11 @@
 	    {
 	      /* OK, we actually have a frame.  */
 	      cache->frameless_p = 0;
-	      return pc + 3;
+	      return pc + 2;
 	    }
 	}
 
-      return pc + 1;
+      return pc;
     }
 
   return pc;
diff --git a/gdb/configure.tgt b/gdb/configure.tgt
index 47e98d9..f9a5ed1 100644
--- a/gdb/configure.tgt
+++ b/gdb/configure.tgt
@@ -228,6 +228,13 @@
 	fi
 	build_gdbserver=yes
 	;;
+x86_64-*-nacl*)
+	# Target: NaCl, remote debugging only.
+	gdb_target_obs="i386-tdep.o glibc-tdep.o i387-tdep.o \
+			solib-svr4.o symfile-mem.o amd64-tdep.o \
+			nacl-manifest.o nacl-tdep.o i386-linux-tdep.o \
+			amd64-linux-tdep.o linux-tdep.o linux-record.o"
+	;;
 i[34567]86-*-gnu*)
 	# Target: Intel 386 running the GNU Hurd
 	gdb_target_obs="i386-tdep.o i387-tdep.o i386gnu-tdep.o solib-svr4.o"
diff --git a/gdb/defs.h b/gdb/defs.h
index 1469299..5ff11ba 100644
--- a/gdb/defs.h
+++ b/gdb/defs.h
@@ -591,6 +591,7 @@
   GDB_OSABI_DICOS,
   GDB_OSABI_DARWIN,
   GDB_OSABI_SYMBIAN,
+  GDB_OSABI_NACL,
   GDB_OSABI_OPENVMS,
   GDB_OSABI_LYNXOS178,
   GDB_OSABI_NEWLIB,
diff --git a/gdb/features/i386/amd64-linux.c b/gdb/features/i386/amd64-linux.c
index 8cbf4bf..1c8875b 100644
--- a/gdb/features/i386/amd64-linux.c
+++ b/gdb/features/i386/amd64-linux.c
@@ -44,8 +44,8 @@
   tdesc_create_reg (feature, "rdx", 3, 1, NULL, 64, "int64");
   tdesc_create_reg (feature, "rsi", 4, 1, NULL, 64, "int64");
   tdesc_create_reg (feature, "rdi", 5, 1, NULL, 64, "int64");
-  tdesc_create_reg (feature, "rbp", 6, 1, NULL, 64, "data_ptr");
-  tdesc_create_reg (feature, "rsp", 7, 1, NULL, 64, "data_ptr");
+  tdesc_create_reg (feature, "rbp", 6, 1, NULL, 64, "int64");
+  tdesc_create_reg (feature, "rsp", 7, 1, NULL, 64, "int64");
   tdesc_create_reg (feature, "r8", 8, 1, NULL, 64, "int64");
   tdesc_create_reg (feature, "r9", 9, 1, NULL, 64, "int64");
   tdesc_create_reg (feature, "r10", 10, 1, NULL, 64, "int64");
@@ -54,7 +54,7 @@
   tdesc_create_reg (feature, "r13", 13, 1, NULL, 64, "int64");
   tdesc_create_reg (feature, "r14", 14, 1, NULL, 64, "int64");
   tdesc_create_reg (feature, "r15", 15, 1, NULL, 64, "int64");
-  tdesc_create_reg (feature, "rip", 16, 1, NULL, 64, "code_ptr");
+  tdesc_create_reg (feature, "rip", 16, 1, NULL, 64, "int64");
   tdesc_create_reg (feature, "eflags", 17, 1, NULL, 32, "i386_eflags");
   tdesc_create_reg (feature, "cs", 18, 1, NULL, 32, "int32");
   tdesc_create_reg (feature, "ss", 19, 1, NULL, 32, "int32");
diff --git a/gdb/frame.c b/gdb/frame.c
index 6a8b5ae..79dea26 100644
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -558,6 +558,7 @@
 frame_id_eq (struct frame_id l, struct frame_id r)
 {
   int eq;
+  const uint32_t max_addr = (uint32_t) -1;
 
   if (!l.stack_addr_p && l.special_addr_p
       && !r.stack_addr_p && r.special_addr_p)
@@ -571,7 +572,12 @@
     /* Like a NaN, if either ID is invalid, the result is false.
        Note that a frame ID is invalid iff it is the null frame ID.  */
     eq = 0;
-  else if (l.stack_addr != r.stack_addr)
+    /* Hack for PNaCl support.  Due to base address hiding
+       stack_addr may differ by base address.  This creates false
+       positives for normal 64-bit mode, so we need to find a better way.  */
+  else if ((l.stack_addr != r.stack_addr && l.stack_addr > max_addr
+	   && r.stack_addr > max_addr)
+	   || (uint32_t)l.stack_addr != (uint32_t)r.stack_addr)
     /* If .stack addresses are different, the frames are different.  */
     eq = 0;
   else if (l.code_addr_p && r.code_addr_p && l.code_addr != r.code_addr)
diff --git a/gdb/i386-linux-tdep.c b/gdb/i386-linux-tdep.c
index b46a51e..ef006e8 100644
--- a/gdb/i386-linux-tdep.c
+++ b/gdb/i386-linux-tdep.c
@@ -709,6 +709,14 @@
   return closure;
 }
 
+void
+i386_linux_init_gregset (struct gdbarch_tdep *tdep)
+{
+  tdep->gregset_reg_offset = i386_linux_gregset_reg_offset;
+  tdep->gregset_num_regs = ARRAY_SIZE (i386_linux_gregset_reg_offset);
+  tdep->sizeof_gregset = 17 * 4;
+}
+
 static void
 i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 {
@@ -747,9 +755,7 @@
 
   tdep->register_reggroup_p = i386_linux_register_reggroup_p;
 
-  tdep->gregset_reg_offset = i386_linux_gregset_reg_offset;
-  tdep->gregset_num_regs = ARRAY_SIZE (i386_linux_gregset_reg_offset);
-  tdep->sizeof_gregset = 17 * 4;
+  i386_linux_init_gregset (tdep);
 
   tdep->jb_pc_offset = 20;	/* From <bits/setjmp.h>.  */
 
diff --git a/gdb/i386-linux-tdep.h b/gdb/i386-linux-tdep.h
index 54b5058..cd3d2c1 100644
--- a/gdb/i386-linux-tdep.h
+++ b/gdb/i386-linux-tdep.h
@@ -67,4 +67,6 @@
 
 extern int i386_linux_gregset_reg_offset[];
 
+extern void i386_linux_init_gregset (struct gdbarch_tdep *tdep);
+
 #endif /* i386-linux-tdep.h */
diff --git a/gdb/nacl-manifest.c b/gdb/nacl-manifest.c
new file mode 100644
index 0000000..a6c4788
--- /dev/null
+++ b/gdb/nacl-manifest.c
@@ -0,0 +1,440 @@
+/* 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 "nacl-manifest.h"
+
+#include "defs.h"
+#include "command.h"
+#include "completer.h"
+#include "exec.h"
+#include "frame.h"
+#include "gdbcore.h"
+#include "observer.h"
+#include "readline/readline.h"
+#include "solib.h"
+#include "symfile.h"
+#include "objfiles.h"
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+
+#define MANIFEST_MAX_NESTING 4
+
+#define MANIFEST_MAX_STRING_SIZE 256
+
+struct file_list
+  {
+    struct file_list *next;
+
+    char original_name[MANIFEST_MAX_STRING_SIZE];
+
+    char name[MANIFEST_MAX_STRING_SIZE];
+  };
+
+/* Mapping of 32-bit *.so libraries.  */
+static struct file_list *nacl_file_list_32 = NULL;
+
+/* Mapping of 64-bit *.so libraries.  */
+static struct file_list *nacl_file_list_64 = NULL;
+
+/* runnable-ld.so or statically linked 32-bit program name.  */
+static char *nacl_program_filename_32 = NULL;
+
+/* runnable-ld.so or statically linked 64-bit program name.  */
+static char *nacl_program_filename_64 = NULL;
+
+const char *
+nacl_manifest_find (char *original_name)
+{
+  struct file_list *curr;
+  int addr_bit;
+
+  /* HACK: NaCl uses "/lib/" library path to inform service runtime that the
+           file should be opened as solib vs. ordinary file. Split that prefix
+           here so that GDB can find these files via manifest or as is.  */
+  if (strncmp (original_name, "/lib/", 5) == 0)
+    original_name += 5;
+
+  addr_bit = gdbarch_addr_bit(target_gdbarch ());
+
+  if (addr_bit == 32)
+    curr = nacl_file_list_32;
+  else if (addr_bit == 64)
+    curr = nacl_file_list_64;
+  else
+    error(_("Can't map files with manifest due to unknown architecture"));
+
+  for (; curr; curr = curr->next)
+    {
+      if (strcmp (original_name, curr->original_name) == 0)
+        return curr->name;
+    }
+
+  if (strcmp(original_name, "NaClMain") == 0)
+    {
+      if (addr_bit == 32 && nacl_program_filename_32)
+	return nacl_program_filename_32;
+      if (addr_bit == 64 && nacl_program_filename_64)
+	return nacl_program_filename_64;
+      error(_("runnable-ld.so not found in manifest"));
+    }
+  if (strlen(original_name) == 0)
+    {
+      return nacl_manifest_find("main.nexe");
+    }
+  /* TODO: Should we complain if we have a manifest but failed to find
+     /lib/filename there? */
+
+  return original_name;
+}
+
+static void
+nacl_manifest_free_list (struct file_list *nacl_file_list)
+{
+  while (nacl_file_list)
+    {
+      struct file_list *next = nacl_file_list->next;
+
+      xfree (nacl_file_list);
+      nacl_file_list = next;
+    }
+}
+
+static void
+nacl_manifest_free (void)
+{
+  nacl_manifest_free_list(nacl_file_list_32);
+  nacl_file_list_32 = NULL;
+  nacl_manifest_free_list(nacl_file_list_64);
+  nacl_file_list_64 = NULL;
+  xfree (nacl_program_filename_32);
+  xfree (nacl_program_filename_64);
+  nacl_program_filename_32 = NULL;
+  nacl_program_filename_64 = NULL;
+}
+
+/* Very dumb parser for JSON subset used in Native Client manifest files.
+   This is a SAX-style parser that runs callbacks on JSON events.  */
+
+struct json_manifest_reader
+  {
+    /* Manifest file.  */
+    FILE *file;
+
+    /* Stack of members being parsed.  */
+    const char *members[MANIFEST_MAX_NESTING];
+
+    /* Members stack size.  */
+    int nesting;
+
+    /* Manifest file directory without slash at the end. */
+    char *dirname;
+  };
+
+static void
+json_on_member (struct json_manifest_reader *r, const char *member)
+{
+  if (r->nesting == MANIFEST_MAX_NESTING)
+    error (_("Invalid manifest file."));
+
+  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,
+		 const 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);
+  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 = 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 = 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);
+    }
+}
+
+/* Basic parsing utilities.  */
+
+static int
+json_getc (struct json_manifest_reader *r)
+{
+  return fgetc (r->file);
+}
+
+static int
+json_getc_nonspace (struct json_manifest_reader *r)
+{
+  int c;
+
+  while (isspace (c = json_getc (r)));
+  return c;
+}
+
+/* Parsing routines.
+
+   json_parse_something assumes we are just going to read first character of
+   something, probably skipping preceding whitespaces.
+
+   json_finish_parse_something assumes we already read first character of
+   something, and checked it was correct.  */
+
+
+static void json_parse_value (struct json_manifest_reader *r);
+
+static void
+json_finish_parse_string (struct json_manifest_reader *r, char *buf, int len)
+{
+  int c;
+
+  for (; len; --len)
+    {
+      c = json_getc (r);
+      if (c == '"')
+        {
+          *buf = '\0';
+          return;
+        }
+
+      if (c == '\n' || c == EOF)
+        break;
+
+      *buf++ = (char)c;
+    }
+
+  error (_("Invalid manifest file."));
+}
+
+/* We only accept non-empty objects.  */
+
+static void
+json_finish_parse_object (struct json_manifest_reader *r)
+{
+  int c;
+  char buf[MANIFEST_MAX_STRING_SIZE];
+
+  do
+    {
+      c = json_getc_nonspace(r);
+      if (c == '}')
+	break;
+      if (c != '\"')
+        error (_("Invalid manifest file."));
+
+      json_finish_parse_string (r, buf, MANIFEST_MAX_STRING_SIZE);
+      json_on_member (r, buf);
+
+      if (json_getc_nonspace (r) != ':')
+        error (_("Invalid manifest file."));
+
+      json_parse_value (r);
+      json_on_end_member (r, buf);
+    }
+  while ((c = json_getc_nonspace (r)) == ',');
+
+  if (c != '}')
+    error (_("Invalid manifest file."));
+}
+
+/* We only accept objects or strings.  */
+
+static void
+json_parse_value (struct json_manifest_reader *r)
+{
+  int c = json_getc_nonspace (r);
+
+  if (c == '{')
+    {
+      json_finish_parse_object (r);
+    }
+  else if (c == '\"')
+    {
+      char buf[MANIFEST_MAX_STRING_SIZE];
+
+      json_finish_parse_string (r, buf, MANIFEST_MAX_STRING_SIZE);
+      json_on_string_value (r, buf);
+    }
+  else
+    {
+      error (_("Invalid manifest file."));
+    }
+}
+
+/* GDB commands for specifying Native Client files.  */
+
+static void
+nacl_irt_command (char *args, int from_tty)
+{
+  if (args)
+    {
+      char **argv;
+      struct cleanup *old_chain;
+      char *nacl_irt_filename;
+
+      argv = gdb_buildargv(args);
+      old_chain = make_cleanup_freeargv(argv);
+      if (*argv == NULL)
+	error (_("No IRT file name was specified"));
+
+      nacl_irt_filename = tilde_expand (*argv);
+      make_cleanup(xfree, nacl_irt_filename);
+
+      symbol_file_add (nacl_irt_filename, from_tty ? SYMFILE_VERBOSE : 0,
+		       NULL, OBJF_USERLOADED);
+      /* Recalculate frames.  */
+      reinit_frame_cache ();
+      do_cleanups(old_chain);
+    }
+}
+
+static struct observer *about_to_proceed_observer = NULL;
+
+static void
+about_to_proceed_hook (void)
+{
+  if (exec_bfd == NULL)
+    {
+      const char *filename = nacl_manifest_find ("NaClMain");
+      exec_file_attach ((char *) filename, 0);
+      symbol_file_add (filename, SYMFILE_MAINLINE, NULL, 0);
+    }
+}
+
+static void
+nacl_manifest_command (char *args, int from_tty)
+{
+  if (args)
+    {
+      char **argv;
+      struct cleanup *old_chain;
+      char *manifest_filename;
+      struct json_manifest_reader r = { 0 };
+
+      argv = gdb_buildargv (args);
+      old_chain = make_cleanup_freeargv (argv);
+      if (*argv == NULL)
+	error (_("No manifest file name was specified"));
+
+      manifest_filename = tilde_expand (*argv);
+      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);
+    }
+}
+
+/* Provide a prototype to silence -Wmissing-prototypes.  */
+extern void _initialize_nacl_manifest (void);
+
+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);
+}
diff --git a/gdb/nacl-manifest.h b/gdb/nacl-manifest.h
new file mode 100644
index 0000000..1035314
--- /dev/null
+++ b/gdb/nacl-manifest.h
@@ -0,0 +1,29 @@
+/* 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/>.  */
+
+#ifndef NACL_MANIFEST_H
+#define NACL_MANIFEST_H
+
+/* Real filename for Native Client program.  */
+const char *nacl_manifest_program (void);
+
+/* Real filename for Native Client original_name.  */
+const char *nacl_manifest_find (char *original_name);
+
+#endif
diff --git a/gdb/nacl-tdep.c b/gdb/nacl-tdep.c
new file mode 100644
index 0000000..068033c
--- /dev/null
+++ b/gdb/nacl-tdep.c
@@ -0,0 +1,250 @@
+/* Target-dependent code for NaCl.
+
+   Copyright (C) 2001, 2003-2012 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 "amd64-linux-tdep.h"
+#include "i386-linux-tdep.h"
+#include "linux-tdep.h"
+#include "amd64-tdep.h"
+#include "nacl-manifest.h"
+#include "symtab.h"
+#include "solib-svr4.h"
+#include "frame.h"
+#include "osabi.h"
+#include "disasm.h"
+#include "breakpoint.h"
+#include "target.h"
+#include "elf-bfd.h"
+#include "inferior.h"
+
+static enum gdb_osabi
+nacl_osabi_sniffer (bfd *abfd)
+{
+  /* We removed Linux remote debugging support from NaCl debugger, so we must
+     handle all ELF files ourselves now.
+
+     If we want to support both Linux and NaCl remote debugging simultaneously,
+     we would have to find some way to distinguish NaCl and Linux binaries here.
+     Currently there is no way to distinguish PNaCl-produced binaries from
+     Linux binaries.
+
+     See issues https://code.google.com/p/nativeclient/issues/detail?id=2971 and
+     https://code.google.com/p/nativeclient/issues/detail?id=3313
+     for details.  */
+  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
+    return GDB_OSABI_NACL;
+
+  return GDB_OSABI_UNKNOWN;
+}
+
+static void
+nacl_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+{
+  /* NaCl uses SVR4-style shared libraries.  */
+  set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
+  set_solib_svr4_map_so_name (gdbarch, nacl_manifest_find);
+  set_gdbarch_process_record (gdbarch, i386_process_record);
+  set_gdbarch_call_dummy_location(gdbarch, AT_ENTRY_POINT);
+}
+
+static void
+i386_nacl_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  linux_init_abi (info, gdbarch);
+  i386_elf_init_abi (info, gdbarch);
+  i386_linux_init_gregset (tdep);
+  tdep->tdesc = tdesc_i386_linux;
+  set_solib_svr4_fetch_link_map_offsets (gdbarch,
+					 svr4_ilp32_fetch_link_map_offsets);
+  nacl_init_abi (info, gdbarch);
+}
+
+static CORE_ADDR
+amd64_nacl_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR val)
+{
+  return val & 0xffffffffUL;
+}
+
+static CORE_ADDR
+amd64_nacl_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame)
+{
+  CORE_ADDR pc;
+  pc = frame_unwind_register_unsigned (this_frame, gdbarch_pc_regnum (gdbarch));
+  return amd64_nacl_addr_bits_remove (gdbarch, pc);
+}
+
+static CORE_ADDR
+amd64_nacl_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
+{
+  CORE_ADDR sp;
+  sp = frame_unwind_register_unsigned (this_frame, gdbarch_sp_regnum (gdbarch));
+  return amd64_nacl_addr_bits_remove (gdbarch, sp);
+}
+
+static struct link_map_offsets *
+amd64_nacl_fetch_link_map_offsets (void)
+{
+  static struct link_map_offsets lmo;
+  static struct link_map_offsets *lmp = NULL;
+
+  if (lmp == NULL)
+    {
+      lmp = &lmo;
+
+      lmo.r_version_offset = 0;
+      lmo.r_version_size = 4;
+      lmo.r_map_offset = 4;
+      lmo.r_brk_offset = 8;
+      /* Dynamic linker is in the normal list of shared objects.  */
+      lmo.r_ldsomap_offset = -1;
+
+      lmo.link_map_size = 24;
+      lmo.l_addr_offset = 0;
+      lmo.l_name_offset = 8;
+      lmo.l_ld_offset = 12;
+      lmo.l_next_offset = 16;
+      lmo.l_prev_offset = 20;
+    }
+
+  return lmp;
+}
+
+static CORE_ADDR
+amd64_nacl_skip_rsp_sandboxing (CORE_ADDR addr)
+{
+  gdb_byte buf[3];
+  if (target_read_memory (addr, buf, sizeof(buf)) == 0)
+    {
+      /* 4c 01 fc    add  %r15,%rsp  */
+      if (buf[0] == 0x4c && buf[1] == 0x01 && buf[2] == 0xfc)
+        {
+          return addr + 3;
+        }
+    }
+  return addr;
+}
+
+static CORE_ADDR
+amd64_nacl_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+  return amd64_nacl_skip_rsp_sandboxing (addr);
+}
+
+static int
+amd64_nacl_software_single_step (struct frame_info *frame)
+{
+  struct gdbarch *gdbarch;
+  CORE_ADDR pc;
+  CORE_ADDR bp_pc;
+
+  gdbarch = get_frame_arch (frame);
+  pc = get_frame_register_unsigned (frame, gdbarch_pc_regnum (gdbarch));
+  pc = amd64_nacl_addr_bits_remove (gdbarch, pc);
+
+  /* Check if next instruction is rsp sandboxing.  If yes, assume current
+     instruction is rsp modification.  */
+  pc += gdb_insn_length (gdbarch, pc);
+  bp_pc = amd64_nacl_skip_rsp_sandboxing (pc);
+  if (bp_pc != pc)
+    {
+      insert_single_step_breakpoint (gdbarch,
+                                     get_frame_address_space (frame),
+                                     bp_pc);
+      return 1;
+    }
+
+  return 0;
+}
+
+static struct frame_id
+amd64_nacl_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
+{
+  CORE_ADDR fp;
+
+  fp = get_frame_register_unsigned (this_frame, AMD64_RBP_REGNUM) + 16;
+  fp = amd64_nacl_addr_bits_remove(gdbarch, fp);
+
+  return frame_id_build (fp, get_frame_pc (this_frame));
+}
+
+static int
+amd64_nacl_inner_than (CORE_ADDR lhs, CORE_ADDR rhs)
+{
+  return (uint32_t)lhs < (uint32_t)rhs;
+}
+
+static void
+amd64_nacl_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+  linux_init_abi (info, gdbarch);
+  amd64_init_abi (info, gdbarch);
+  amd64_linux_init_gregset (tdep);
+  tdep->tdesc = tdesc_amd64_linux;
+  set_solib_svr4_fetch_link_map_offsets (gdbarch,
+					 amd64_nacl_fetch_link_map_offsets);
+  nacl_init_abi (info, gdbarch);
+
+  /* NaCl data model.
+
+     WARNING! This might confuse a lot of code, as it uses
+       if (set_gdbarch_ptr_bit (gdbarch) == <bits>)
+     to distinguish between i386 and x86_64 (lame!).  Luckily, most of that
+     code is about native debugging and syscalls, so it is not used for NaCl.
+
+     TODO(eaeltsin): find better way to distinguish between i386 and x86_64!  */
+  set_gdbarch_long_bit (gdbarch, 32);
+  set_gdbarch_ptr_bit (gdbarch, 32);
+
+  /* TODO(eaeltsin): we might use address size instead of pointer size to
+     distinguish between i386 and x86_64...  At least address size is not
+     a property of the data model.  */
+  set_gdbarch_addr_bit (gdbarch, 64);
+
+  /* How to extract addresses from registers.  */
+  set_gdbarch_addr_bits_remove (gdbarch, amd64_nacl_addr_bits_remove);
+  set_gdbarch_unwind_pc (gdbarch, amd64_nacl_unwind_pc);
+  set_gdbarch_unwind_sp (gdbarch, amd64_nacl_unwind_sp);
+  set_gdbarch_inner_than (gdbarch, amd64_nacl_inner_than);
+
+  /* Where to set breakpoints.  */
+  set_gdbarch_adjust_breakpoint_address (gdbarch,
+                                         amd64_nacl_adjust_breakpoint_address);
+  set_gdbarch_software_single_step (gdbarch, amd64_nacl_software_single_step);
+  /* Recognizing dummy frames.  */
+  set_gdbarch_dummy_id(gdbarch, amd64_nacl_dummy_id);
+}
+
+/* Provide a prototype to silence -Wmissing-prototypes.  */
+extern void _initialize_nacl_tdep (void);
+
+void
+_initialize_nacl_tdep (void)
+{
+  gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_elf_flavour,
+				  nacl_osabi_sniffer);
+
+  gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64,
+			  GDB_OSABI_NACL, amd64_nacl_init_abi);
+
+  gdbarch_register_osabi (bfd_arch_i386, 0,
+			  GDB_OSABI_NACL, i386_nacl_init_abi);
+}
diff --git a/gdb/osabi.c b/gdb/osabi.c
index a170974..93f434a 100644
--- a/gdb/osabi.c
+++ b/gdb/osabi.c
@@ -71,6 +71,7 @@
   "DICOS",
   "Darwin",
   "Symbian",
+  "NaCl",
   "OpenVMS",
   "LynxOS178",
   "Newlib",
diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
index 9538af6..0a7c1ca 100644
--- a/gdb/solib-svr4.c
+++ b/gdb/solib-svr4.c
@@ -51,6 +51,8 @@
 static struct link_map_offsets *svr4_fetch_link_map_offsets (void);
 static int svr4_have_link_map_offsets (void);
 static void svr4_relocate_main_executable (void);
+static const char *svr4_map_so_name(char *name);
+static int svr4_have_map_so_name (void);
 static void svr4_free_library_list (void *p_list);
 
 /* Link map info to include in an allocated so_list entry.  */
@@ -1369,7 +1371,15 @@
 	  continue;
 	}
 
-      strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
+      if (svr4_have_map_so_name ())
+	{
+	  strncpy (new->so_name, svr4_map_so_name (buffer),
+	           SO_NAME_MAX_PATH_SIZE - 1);
+	}
+      else
+	{
+	  strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
+	}
       new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
       strcpy (new->so_original_name, new->so_name);
       xfree (buffer);
@@ -1435,7 +1445,7 @@
 
   /* Assume that everything is a library if the dynamic loader was loaded
      late by a static executable.  */
-  if (exec_bfd && bfd_get_section_by_name (exec_bfd, ".dynamic") == NULL)
+  if (exec_bfd && find_program_interpreter() == NULL)
     ignore_first = 0;
   else
     ignore_first = 1;
@@ -2985,6 +2995,8 @@
 {
   /* Return a description of the layout of `struct link_map'.  */
   struct link_map_offsets *(*fetch_link_map_offsets)(void);
+  /* Return real path for the solib name given by ld.so.  */
+  const char *(*map_so_name)(char*);
 };
 
 /* Return a default for the architecture-specific operations.  */
@@ -2996,6 +3008,7 @@
 
   ops = OBSTACK_ZALLOC (obstack, struct solib_svr4_ops);
   ops->fetch_link_map_offsets = NULL;
+  ops->map_so_name = NULL;
   return ops;
 }
 
@@ -3013,6 +3026,17 @@
   set_solib_ops (gdbarch, &svr4_so_ops);
 }
 
+/* Set function to map ld.so solib names to real paths.  */
+
+void
+set_solib_svr4_map_so_name(struct gdbarch *gdbarch,
+                           const char* (*map_so_name) (char*))
+{
+  struct solib_svr4_ops *ops = gdbarch_data (gdbarch, solib_svr4_data);
+
+  ops->map_so_name = map_so_name;
+}
+
 /* Fetch a link_map_offsets structure using the architecture-specific
    `struct link_map_offsets' fetcher.  */
 
@@ -3034,6 +3058,25 @@
 
   return (ops->fetch_link_map_offsets != NULL);
 }
+
+/* Return real path for the solib name given by ld.so.  */
+
+static const char *
+svr4_map_so_name(char *name)
+{
+  struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data);
+  gdb_assert (ops->map_so_name);
+  return ops->map_so_name (name);
+}
+
+/* Return 1 if a solib name map function has been defined, 0 otherwise.  */
+
+static int
+svr4_have_map_so_name(void)
+{
+  struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data);
+  return (ops->map_so_name != NULL);
+}
 
 
 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
diff --git a/gdb/solib-svr4.h b/gdb/solib-svr4.h
index 66a06e1..ff04d2f 100644
--- a/gdb/solib-svr4.h
+++ b/gdb/solib-svr4.h
@@ -71,6 +71,9 @@
 extern void set_solib_svr4_fetch_link_map_offsets
   (struct gdbarch *gdbarch, struct link_map_offsets *(*func) (void));
 
+extern void set_solib_svr4_map_so_name
+  (struct gdbarch *gdbarch, const char *(*map_so_name) (char*));
+
 /* This function is called by thread_db.c.  Return the address of the
    link map for the given objfile.  */
 extern CORE_ADDR svr4_fetch_objfile_link_map (struct objfile *objfile);
diff --git a/gdb/utils.c b/gdb/utils.c
index 975c432..4172f23 100644
--- a/gdb/utils.c
+++ b/gdb/utils.c
@@ -72,6 +72,10 @@
 #include "interps.h"
 #include "gdb_regex.h"
 
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include <windows.h>
+#endif
+
 #if !HAVE_DECL_MALLOC
 extern PTR malloc ();		/* ARI: PTR */
 #endif
@@ -193,6 +197,20 @@
 }
 
 
+#if defined(_WIN32) && !defined(__CYGWIN__)
+
+static void
+do_freeargv (void *arg)
+{
+  int i = 0;
+  char** args = (char**) arg;
+  for (i = 0; args[i] != NULL; i++)
+    free(args[i]);
+  free(args);
+}
+
+#else
+
 /* Cleanup utilities.
 
    These are not defined in cleanups.c (nor declared in cleanups.h)
@@ -205,6 +223,8 @@
   freeargv ((char **) arg);
 }
 
+#endif
+
 struct cleanup *
 make_cleanup_freeargv (char **arg)
 {
@@ -3484,6 +3504,45 @@
   return dirname;
 }
 
+#if defined(_WIN32) && !defined(__CYGWIN__)
+
+char **
+gdb_buildargv (const char *s)
+{
+  LPWSTR wide_string;
+  int wide_len;
+  int arg_len;
+  int num_args;
+  LPWSTR* args;
+  char** result;
+  int i;
+  if (s == NULL)
+    return NULL;
+  wide_len = MultiByteToWideChar(CP_UTF8, 0, s, -1, NULL, 0);
+  wide_string = malloc(2 * wide_len);
+  if (wide_string == NULL)
+    malloc_failure (0);
+  MultiByteToWideChar(CP_UTF8, 0, s, -1, wide_string, wide_len);
+  args = CommandLineToArgvW(wide_string, &num_args);
+  free(wide_string);
+  result = malloc((num_args + 1) * sizeof(char*));
+  for (i = 0; i < num_args; i++)
+    {
+      arg_len = WideCharToMultiByte(CP_UTF8, 0, args[i], -1, NULL, 0,
+                                    NULL, NULL);
+      result[i] = malloc(arg_len);
+      if (result[i] == NULL)
+        malloc_failure(0);
+      WideCharToMultiByte(CP_UTF8, 0, args[i], -1, result[i], arg_len,
+                          NULL, NULL);
+    }
+  result[num_args] = NULL;
+  LocalFree(args);
+  return result;
+}
+
+#else
+
 /* Call libiberty's buildargv, and return the result.
    If buildargv fails due to out-of-memory, call nomem.
    Therefore, the returned value is guaranteed to be non-NULL,
@@ -3499,6 +3558,8 @@
   return argv;
 }
 
+#endif
+
 int
 compare_positive_ints (const void *ap, const void *bp)
 {