diff --git a/gdb/linux-record.c b/gdb/linux-record.c
index 2e86936..d171497 100644
--- a/gdb/linux-record.c
+++ b/gdb/linux-record.c
@@ -87,8 +87,8 @@
 
 static int
 record_linux_sockaddr (struct regcache *regcache,
-                       struct linux_record_tdep *tdep, ULONGEST addr,
-                       ULONGEST len)
+		       struct linux_record_tdep *tdep, ULONGEST addr,
+		       ULONGEST len)
 {
   gdb_byte *a;
   int addrlen;
@@ -107,11 +107,11 @@ record_linux_sockaddr (struct regcache *regcache,
   if (target_read_memory ((CORE_ADDR) len, a, tdep->size_int))
     {
       if (record_debug)
-        fprintf_unfiltered (gdb_stdlog,
-                            "Process record: error reading "
-                            "memory at addr = 0x%s len = %d.\n",
-                            phex_nz (len, tdep->size_pointer),
-                            tdep->size_int);
+	fprintf_unfiltered (gdb_stdlog,
+			    "Process record: error reading "
+			    "memory at addr = 0x%s len = %d.\n",
+			    phex_nz (len, tdep->size_pointer),
+			    tdep->size_int);
       return -1;
     }
   addrlen = (int) extract_unsigned_integer (a, tdep->size_int, byte_order);
@@ -126,7 +126,7 @@ record_linux_sockaddr (struct regcache *regcache,
 
 static int
 record_linux_msghdr (struct regcache *regcache,
-                     struct linux_record_tdep *tdep, ULONGEST addr)
+		     struct linux_record_tdep *tdep, ULONGEST addr)
 {
   gdb_byte *a;
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
@@ -144,12 +144,12 @@ record_linux_msghdr (struct regcache *regcache,
   if (target_read_memory ((CORE_ADDR) addr, a, tdep->size_msghdr))
     {
       if (record_debug)
-        fprintf_unfiltered (gdb_stdlog,
-                            "Process record: error reading "
-                            "memory at addr = 0x%s "
-                            "len = %d.\n",
-                            phex_nz (addr, tdep->size_pointer),
-                            tdep->size_msghdr);
+	fprintf_unfiltered (gdb_stdlog,
+			    "Process record: error reading "
+			    "memory at addr = 0x%s "
+			    "len = %d.\n",
+			    phex_nz (addr, tdep->size_pointer),
+			    tdep->size_msghdr);
       return -1;
     }
 
@@ -173,33 +173,33 @@ record_linux_msghdr (struct regcache *regcache,
     {
       ULONGEST i;
       ULONGEST len = extract_unsigned_integer (a, tdep->size_size_t,
-                                               byte_order);
+					       byte_order);
       gdb_byte *iov = (gdb_byte *) alloca (tdep->size_iovec);
 
       for (i = 0; i < len; i++)
-        {
-          if (target_read_memory ((CORE_ADDR) addr, iov, tdep->size_iovec))
-            {
-              if (record_debug)
-                fprintf_unfiltered (gdb_stdlog,
-                                    "Process record: error "
-                                    "reading memory at "
-                                    "addr = 0x%s "
-                                    "len = %d.\n",
-                                    phex_nz (addr,tdep->size_pointer),
-                                    tdep->size_iovec);
-              return -1;
-            }
-          tmpaddr = (CORE_ADDR) extract_unsigned_integer (iov,
-                                                          tdep->size_pointer,
-                                                          byte_order);
-          tmpint = (int) extract_unsigned_integer (iov + tdep->size_pointer,
-                                                   tdep->size_size_t,
-                                                   byte_order);
-          if (record_full_arch_list_add_mem (tmpaddr, tmpint))
-            return -1;
-          addr += tdep->size_iovec;
-        }
+	{
+	  if (target_read_memory ((CORE_ADDR) addr, iov, tdep->size_iovec))
+	    {
+	      if (record_debug)
+		fprintf_unfiltered (gdb_stdlog,
+				    "Process record: error "
+				    "reading memory at "
+				    "addr = 0x%s "
+				    "len = %d.\n",
+				    phex_nz (addr,tdep->size_pointer),
+				    tdep->size_iovec);
+	      return -1;
+	    }
+	  tmpaddr = (CORE_ADDR) extract_unsigned_integer (iov,
+							  tdep->size_pointer,
+							  byte_order);
+	  tmpint = (int) extract_unsigned_integer (iov + tdep->size_pointer,
+						   tdep->size_size_t,
+						   byte_order);
+	  if (record_full_arch_list_add_mem (tmpaddr, tmpint))
+	    return -1;
+	  addr += tdep->size_iovec;
+	}
     }
   a += tdep->size_size_t;
 
@@ -226,9 +226,9 @@ record_linux_msghdr (struct regcache *regcache,
    Return -1 if something wrong.  */
 
 int
-record_linux_system_call (enum gdb_syscall syscall, 
+record_linux_system_call (enum gdb_syscall syscall,
 			  struct regcache *regcache,
-                          struct linux_record_tdep *tdep)
+			  struct linux_record_tdep *tdep)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
@@ -243,15 +243,15 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_sys_exit:
       {
-        int q;
-
-        target_terminal_ours ();
-        q = yquery (_("The next instruction is syscall exit.  "
-                      "It will make the program exit.  "
-                      "Do you want to stop the program?"));
-        target_terminal_inferior ();
-        if (q)
-          return 1;
+	int q;
+
+	target_terminal_ours ();
+	q = yquery (_("The next instruction is syscall exit.  "
+		      "It will make the program exit.  "
+		      "Do you want to stop the program?"));
+	target_terminal_inferior ();
+	if (q)
+	  return 1;
       }
       break;
 
@@ -260,12 +260,12 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_sys_read:
       {
-        ULONGEST addr, count;
+	ULONGEST addr, count;
 
-        regcache_raw_read_unsigned (regcache, tdep->arg2, &addr);
-        regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
-        if (record_full_arch_list_add_mem ((CORE_ADDR) addr, (int) count))
-          return -1;
+	regcache_raw_read_unsigned (regcache, tdep->arg2, &addr);
+	regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
+	if (record_full_arch_list_add_mem ((CORE_ADDR) addr, (int) count))
+	  return -1;
       }
       break;
 
@@ -277,9 +277,9 @@ record_linux_system_call (enum gdb_syscall syscall,
     case gdb_sys_waitpid:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					   tdep->size_int))
-          return -1;
+	  return -1;
       break;
 
     case gdb_sys_creat:
@@ -292,9 +292,9 @@ record_linux_system_call (enum gdb_syscall syscall,
     case gdb_sys_time:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest)
-        if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					   tdep->size_time_t))
-          return -1;
+	  return -1;
       break;
 
     case gdb_sys_mknod:
@@ -309,7 +309,7 @@ record_linux_system_call (enum gdb_syscall syscall,
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size__old_kernel_stat))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_lseek:
@@ -324,14 +324,14 @@ record_linux_system_call (enum gdb_syscall syscall,
     case gdb_sys_ptrace:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest == RECORD_PTRACE_PEEKTEXT
-          || tmpulongest == RECORD_PTRACE_PEEKDATA
-          || tmpulongest == RECORD_PTRACE_PEEKUSR)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg4,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
-            return -1;
-        }
+	  || tmpulongest == RECORD_PTRACE_PEEKDATA
+	  || tmpulongest == RECORD_PTRACE_PEEKUSR)
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg4,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
+	    return -1;
+	}
       break;
 
     case gdb_sys_alarm:
@@ -354,14 +354,14 @@ record_linux_system_call (enum gdb_syscall syscall,
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int * 2))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_times:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_tms))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_ni_syscall44:
@@ -380,155 +380,155 @@ record_linux_system_call (enum gdb_syscall syscall,
       /* XXX Need to add a lot of support of other ioctl requests.  */
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest == tdep->ioctl_FIOCLEX
-          || tmpulongest == tdep->ioctl_FIONCLEX
-          || tmpulongest == tdep->ioctl_FIONBIO
-          || tmpulongest == tdep->ioctl_FIOASYNC
-          || tmpulongest == tdep->ioctl_TCSETS
-          || tmpulongest == tdep->ioctl_TCSETSW
-          || tmpulongest == tdep->ioctl_TCSETSF
-          || tmpulongest == tdep->ioctl_TCSETA
-          || tmpulongest == tdep->ioctl_TCSETAW
-          || tmpulongest == tdep->ioctl_TCSETAF
-          || tmpulongest == tdep->ioctl_TCSBRK
-          || tmpulongest == tdep->ioctl_TCXONC
-          || tmpulongest == tdep->ioctl_TCFLSH
-          || tmpulongest == tdep->ioctl_TIOCEXCL
-          || tmpulongest == tdep->ioctl_TIOCNXCL
-          || tmpulongest == tdep->ioctl_TIOCSCTTY
-          || tmpulongest == tdep->ioctl_TIOCSPGRP
-          || tmpulongest == tdep->ioctl_TIOCSTI
-          || tmpulongest == tdep->ioctl_TIOCSWINSZ
-          || tmpulongest == tdep->ioctl_TIOCMBIS
-          || tmpulongest == tdep->ioctl_TIOCMBIC
-          || tmpulongest == tdep->ioctl_TIOCMSET
-          || tmpulongest == tdep->ioctl_TIOCSSOFTCAR
-          || tmpulongest == tdep->ioctl_TIOCCONS
-          || tmpulongest == tdep->ioctl_TIOCSSERIAL
-          || tmpulongest == tdep->ioctl_TIOCPKT
-          || tmpulongest == tdep->ioctl_TIOCNOTTY
-          || tmpulongest == tdep->ioctl_TIOCSETD
-          || tmpulongest == tdep->ioctl_TCSBRKP
-          || tmpulongest == tdep->ioctl_TIOCTTYGSTRUCT
-          || tmpulongest == tdep->ioctl_TIOCSBRK
-          || tmpulongest == tdep->ioctl_TIOCCBRK
-          || tmpulongest == tdep->ioctl_TCSETS2
-          || tmpulongest == tdep->ioctl_TCSETSW2
-          || tmpulongest == tdep->ioctl_TCSETSF2
-          || tmpulongest == tdep->ioctl_TIOCSPTLCK
-          || tmpulongest == tdep->ioctl_TIOCSERCONFIG
-          || tmpulongest == tdep->ioctl_TIOCSERGWILD
-          || tmpulongest == tdep->ioctl_TIOCSERSWILD
-          || tmpulongest == tdep->ioctl_TIOCSLCKTRMIOS
-          || tmpulongest == tdep->ioctl_TIOCSERGETMULTI
-          || tmpulongest == tdep->ioctl_TIOCSERSETMULTI
-          || tmpulongest == tdep->ioctl_TIOCMIWAIT
-          || tmpulongest == tdep->ioctl_TIOCSHAYESESP)
-        {
-          /* Nothing to do.  */
-        }
+	  || tmpulongest == tdep->ioctl_FIONCLEX
+	  || tmpulongest == tdep->ioctl_FIONBIO
+	  || tmpulongest == tdep->ioctl_FIOASYNC
+	  || tmpulongest == tdep->ioctl_TCSETS
+	  || tmpulongest == tdep->ioctl_TCSETSW
+	  || tmpulongest == tdep->ioctl_TCSETSF
+	  || tmpulongest == tdep->ioctl_TCSETA
+	  || tmpulongest == tdep->ioctl_TCSETAW
+	  || tmpulongest == tdep->ioctl_TCSETAF
+	  || tmpulongest == tdep->ioctl_TCSBRK
+	  || tmpulongest == tdep->ioctl_TCXONC
+	  || tmpulongest == tdep->ioctl_TCFLSH
+	  || tmpulongest == tdep->ioctl_TIOCEXCL
+	  || tmpulongest == tdep->ioctl_TIOCNXCL
+	  || tmpulongest == tdep->ioctl_TIOCSCTTY
+	  || tmpulongest == tdep->ioctl_TIOCSPGRP
+	  || tmpulongest == tdep->ioctl_TIOCSTI
+	  || tmpulongest == tdep->ioctl_TIOCSWINSZ
+	  || tmpulongest == tdep->ioctl_TIOCMBIS
+	  || tmpulongest == tdep->ioctl_TIOCMBIC
+	  || tmpulongest == tdep->ioctl_TIOCMSET
+	  || tmpulongest == tdep->ioctl_TIOCSSOFTCAR
+	  || tmpulongest == tdep->ioctl_TIOCCONS
+	  || tmpulongest == tdep->ioctl_TIOCSSERIAL
+	  || tmpulongest == tdep->ioctl_TIOCPKT
+	  || tmpulongest == tdep->ioctl_TIOCNOTTY
+	  || tmpulongest == tdep->ioctl_TIOCSETD
+	  || tmpulongest == tdep->ioctl_TCSBRKP
+	  || tmpulongest == tdep->ioctl_TIOCTTYGSTRUCT
+	  || tmpulongest == tdep->ioctl_TIOCSBRK
+	  || tmpulongest == tdep->ioctl_TIOCCBRK
+	  || tmpulongest == tdep->ioctl_TCSETS2
+	  || tmpulongest == tdep->ioctl_TCSETSW2
+	  || tmpulongest == tdep->ioctl_TCSETSF2
+	  || tmpulongest == tdep->ioctl_TIOCSPTLCK
+	  || tmpulongest == tdep->ioctl_TIOCSERCONFIG
+	  || tmpulongest == tdep->ioctl_TIOCSERGWILD
+	  || tmpulongest == tdep->ioctl_TIOCSERSWILD
+	  || tmpulongest == tdep->ioctl_TIOCSLCKTRMIOS
+	  || tmpulongest == tdep->ioctl_TIOCSERGETMULTI
+	  || tmpulongest == tdep->ioctl_TIOCSERSETMULTI
+	  || tmpulongest == tdep->ioctl_TIOCMIWAIT
+	  || tmpulongest == tdep->ioctl_TIOCSHAYESESP)
+	{
+	  /* Nothing to do.  */
+	}
       else if (tmpulongest == tdep->ioctl_TCGETS
-               || tmpulongest == tdep->ioctl_TCGETA
-               || tmpulongest == tdep->ioctl_TIOCGLCKTRMIOS)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	       || tmpulongest == tdep->ioctl_TCGETA
+	       || tmpulongest == tdep->ioctl_TIOCGLCKTRMIOS)
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_termios))
-            return -1;
-        }
+	    return -1;
+	}
       else if (tmpulongest == tdep->ioctl_TIOCGPGRP
-               || tmpulongest == tdep->ioctl_TIOCGSID)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	       || tmpulongest == tdep->ioctl_TIOCGSID)
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_pid_t))
-            return -1;
-        }
+	    return -1;
+	}
       else if (tmpulongest == tdep->ioctl_TIOCOUTQ
-               || tmpulongest == tdep->ioctl_TIOCMGET
-               || tmpulongest == tdep->ioctl_TIOCGSOFTCAR
-               || tmpulongest == tdep->ioctl_FIONREAD
-               || tmpulongest == tdep->ioctl_TIOCINQ
-               || tmpulongest == tdep->ioctl_TIOCGETD
-               || tmpulongest == tdep->ioctl_TIOCGPTN
-               || tmpulongest == tdep->ioctl_TIOCSERGETLSR)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	       || tmpulongest == tdep->ioctl_TIOCMGET
+	       || tmpulongest == tdep->ioctl_TIOCGSOFTCAR
+	       || tmpulongest == tdep->ioctl_FIONREAD
+	       || tmpulongest == tdep->ioctl_TIOCINQ
+	       || tmpulongest == tdep->ioctl_TIOCGETD
+	       || tmpulongest == tdep->ioctl_TIOCGPTN
+	       || tmpulongest == tdep->ioctl_TIOCSERGETLSR)
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_int))
-            return -1;
-        }
+	    return -1;
+	}
       else if (tmpulongest == tdep->ioctl_TIOCGWINSZ)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_winsize))
-            return -1;
-        }
+	    return -1;
+	}
       else if (tmpulongest == tdep->ioctl_TIOCLINUX)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
 	  /* This syscall affects a char-size memory.  */
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1))
-            return -1;
-        }
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1))
+	    return -1;
+	}
       else if (tmpulongest == tdep->ioctl_TIOCGSERIAL)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_serial_struct))
-            return -1;
-        }
+	    return -1;
+	}
       else if (tmpulongest == tdep->ioctl_TCGETS2)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_termios2))
-            return -1;
-        }
+	    return -1;
+	}
       else if (tmpulongest == tdep->ioctl_FIOQSIZE)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_loff_t))
-            return -1;
-        }
+	    return -1;
+	}
       else if (tmpulongest == tdep->ioctl_TIOCGICOUNT)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_serial_icounter_struct))
-            return -1;
-        }
+	    return -1;
+	}
       else if (tmpulongest == tdep->ioctl_TIOCGHAYESESP)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_hayes_esp_config))
-            return -1;
-        }
+	    return -1;
+	}
       else if (tmpulongest == tdep->ioctl_TIOCSERGSTRUCT)
-        {
-          printf_unfiltered (_("Process record and replay target doesn't "
-                               "support ioctl request TIOCSERGSTRUCT\n"));
-          return 1;
-        }
+	{
+	  printf_unfiltered (_("Process record and replay target doesn't "
+			       "support ioctl request TIOCSERGSTRUCT\n"));
+	  return 1;
+	}
       else
-        {
-          printf_unfiltered (_("Process record and replay target doesn't "
-                               "support ioctl request 0x%s.\n"),
-                             OUTPUT_REG (tmpulongest, tdep->arg2));
-          return 1;
-        }
+	{
+	  printf_unfiltered (_("Process record and replay target doesn't "
+			       "support ioctl request 0x%s.\n"),
+			     OUTPUT_REG (tmpulongest, tdep->arg2));
+	  return 1;
+	}
       break;
 
     case gdb_sys_fcntl:
@@ -536,13 +536,13 @@ record_linux_system_call (enum gdb_syscall syscall,
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
     sys_fcntl:
       if (tmpulongest == tdep->fcntl_F_GETLK)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_flock))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_ni_syscall56:
@@ -554,7 +554,7 @@ record_linux_system_call (enum gdb_syscall syscall,
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_oldold_utsname))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_umask:
@@ -565,7 +565,7 @@ record_linux_system_call (enum gdb_syscall syscall,
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_ustat))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_dup2:
@@ -578,7 +578,7 @@ record_linux_system_call (enum gdb_syscall syscall,
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_old_sigaction))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_sgetmask:
@@ -592,7 +592,7 @@ record_linux_system_call (enum gdb_syscall syscall,
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_old_sigset_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_sethostname:
@@ -603,25 +603,25 @@ record_linux_system_call (enum gdb_syscall syscall,
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_rlimit))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_getrusage:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_rusage))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_gettimeofday:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_timeval))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_timezone))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_settimeofday:
@@ -630,15 +630,15 @@ record_linux_system_call (enum gdb_syscall syscall,
     case gdb_sys_getgroups16:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST gidsetsize;
+	{
+	  ULONGEST gidsetsize;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg1,
-                                      &gidsetsize);
-          tmpint = tdep->size_old_gid_t * (int) gidsetsize;
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
-            return -1;
-        }
+	  regcache_raw_read_unsigned (regcache, tdep->arg1,
+				      &gidsetsize);
+	  tmpint = tdep->size_old_gid_t * (int) gidsetsize;
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
+	    return -1;
+	}
       break;
 
     case gdb_sys_setgroups16:
@@ -646,46 +646,46 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_old_select:
       {
-        unsigned long sz_sel_arg = tdep->size_long + tdep->size_pointer * 4;
-        gdb_byte *a = (gdb_byte *) alloca (sz_sel_arg);
-        CORE_ADDR inp, outp, exp, tvp;
-
-        regcache_raw_read_unsigned (regcache, tdep->arg1,
-                                    &tmpulongest);
-        if (tmpulongest)
-          {
-            if (target_read_memory (tmpulongest, a, sz_sel_arg))
-              {
-                if (record_debug)
-                  fprintf_unfiltered (gdb_stdlog,
-                                      "Process record: error reading memory "
-                                      "at addr = 0x%s len = %lu.\n",
-                                      OUTPUT_REG (tmpulongest, tdep->arg1),
-                                      sz_sel_arg);
-                return -1;
-              }
-            /* Skip n. */
-            a += tdep->size_long;
-            inp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
-            a += tdep->size_pointer;
-            outp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
-            a += tdep->size_pointer;
-            exp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
-            a += tdep->size_pointer;
-            tvp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
-            if (inp)
-              if (record_full_arch_list_add_mem (inp, tdep->size_fd_set))
-                return -1;
-            if (outp)
-              if (record_full_arch_list_add_mem (outp, tdep->size_fd_set))
-                return -1;
-            if (exp)
-              if (record_full_arch_list_add_mem (exp, tdep->size_fd_set))
-                return -1;
-            if (tvp)
-              if (record_full_arch_list_add_mem (tvp, tdep->size_timeval))
-                return -1;
-          }
+	unsigned long sz_sel_arg = tdep->size_long + tdep->size_pointer * 4;
+	gdb_byte *a = (gdb_byte *) alloca (sz_sel_arg);
+	CORE_ADDR inp, outp, exp, tvp;
+
+	regcache_raw_read_unsigned (regcache, tdep->arg1,
+				    &tmpulongest);
+	if (tmpulongest)
+	  {
+	    if (target_read_memory (tmpulongest, a, sz_sel_arg))
+	      {
+		if (record_debug)
+		  fprintf_unfiltered (gdb_stdlog,
+				      "Process record: error reading memory "
+				      "at addr = 0x%s len = %lu.\n",
+				      OUTPUT_REG (tmpulongest, tdep->arg1),
+				      sz_sel_arg);
+		return -1;
+	      }
+	    /* Skip n. */
+	    a += tdep->size_long;
+	    inp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
+	    a += tdep->size_pointer;
+	    outp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
+	    a += tdep->size_pointer;
+	    exp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
+	    a += tdep->size_pointer;
+	    tvp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
+	    if (inp)
+	      if (record_full_arch_list_add_mem (inp, tdep->size_fd_set))
+		return -1;
+	    if (outp)
+	      if (record_full_arch_list_add_mem (outp, tdep->size_fd_set))
+		return -1;
+	    if (exp)
+	      if (record_full_arch_list_add_mem (exp, tdep->size_fd_set))
+		return -1;
+	    if (tvp)
+	      if (record_full_arch_list_add_mem (tvp, tdep->size_timeval))
+		return -1;
+	  }
       }
       break;
 
@@ -694,13 +694,13 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_sys_readlink:
       {
-        ULONGEST len;
+	ULONGEST len;
 
-        regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                    &tmpulongest);
-        regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
-        if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
-          return -1;
+	regcache_raw_read_unsigned (regcache, tdep->arg2,
+				    &tmpulongest);
+	regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
+	if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
+	  return -1;
       }
       break;
 
@@ -710,15 +710,15 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_sys_reboot:
       {
-        int q;
+	int q;
 
-        target_terminal_ours ();
-        q = yquery (_("The next instruction is syscall reboot.  "
+	target_terminal_ours ();
+	q = yquery (_("The next instruction is syscall reboot.  "
 		      "It will restart the computer.  "
 		      "Do you want to stop the program?"));
-        target_terminal_inferior ();
-        if (q)
-          return 1;
+	target_terminal_inferior ();
+	if (q)
+	  return 1;
       }
       break;
 
@@ -726,7 +726,7 @@ record_linux_system_call (enum gdb_syscall syscall,
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_old_dirent))
-        return -1;
+	return -1;
       break;
 
     case gdb_old_mmap:
@@ -734,26 +734,26 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_sys_munmap:
       {
-        ULONGEST len;
+	ULONGEST len;
 
-        regcache_raw_read_unsigned (regcache, tdep->arg1,
-                                    &tmpulongest);
-        regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
-        if (record_full_memory_query)
-          {
+	regcache_raw_read_unsigned (regcache, tdep->arg1,
+				    &tmpulongest);
+	regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
+	if (record_full_memory_query)
+	  {
 	    int q;
 
-            target_terminal_ours ();
-            q = yquery (_("\
+	    target_terminal_ours ();
+	    q = yquery (_("\
 The next instruction is syscall munmap.\n\
 It will free the memory addr = 0x%s len = %u.\n\
 It will make record target cannot record some memory change.\n\
 Do you want to stop the program?"),
-                        OUTPUT_REG (tmpulongest, tdep->arg1), (int) len);
-            target_terminal_inferior ();
-            if (q)
-              return 1;
-          }
+			OUTPUT_REG (tmpulongest, tdep->arg1), (int) len);
+	    target_terminal_inferior ();
+	    if (q)
+	      return 1;
+	  }
       }
       break;
 
@@ -771,7 +771,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_statfs))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_ioperm:
@@ -791,313 +791,313 @@ Do you want to stop the program?"),
     case gdb_sys_getsockname:
     case gdb_sys_getpeername:
       {
-        ULONGEST len;
+	ULONGEST len;
 
-        regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-        regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
-        if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
-          return -1;
+	regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+	regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
+	if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
+	  return -1;
       }
       break;
 
     case gdb_sys_recvfrom:
       {
-        ULONGEST len;
+	ULONGEST len;
 
-        regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-        regcache_raw_read_unsigned (regcache, tdep->arg5, &len);
-        if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
-          return -1;
+	regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
+	regcache_raw_read_unsigned (regcache, tdep->arg5, &len);
+	if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
+	  return -1;
       }
       break;
 
     case gdb_sys_recv:
       {
-        ULONGEST size;
+	ULONGEST size;
 
-        regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-        regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
-        if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+	regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
+	if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					   (int) size))
-          return -1;
+	  return -1;
       }
       break;
 
     case gdb_sys_recvmsg:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_linux_msghdr (regcache, tdep, tmpulongest))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_socketpair:
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_getsockopt:
       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST optvalp;
-          gdb_byte *optlenp = (gdb_byte *) alloca (tdep->size_int);
-
-          if (target_read_memory ((CORE_ADDR) tmpulongest, optlenp,
-                                  tdep->size_int))
-            {
-              if (record_debug)
-                fprintf_unfiltered (gdb_stdlog,
-                                    "Process record: error reading "
-                                    "memory at addr = 0x%s "
-                                    "len = %d.\n",
-                                    OUTPUT_REG (tmpulongest, tdep->arg5),
-                                    tdep->size_int);
-              return -1;
-            }
-          regcache_raw_read_unsigned (regcache, tdep->arg4, &optvalp);
-          tmpint = (int) extract_signed_integer (optlenp, tdep->size_int,
-                                                 byte_order);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) optvalp, tmpint))
-            return -1;
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	  ULONGEST optvalp;
+	  gdb_byte *optlenp = (gdb_byte *) alloca (tdep->size_int);
+
+	  if (target_read_memory ((CORE_ADDR) tmpulongest, optlenp,
+				  tdep->size_int))
+	    {
+	      if (record_debug)
+		fprintf_unfiltered (gdb_stdlog,
+				    "Process record: error reading "
+				    "memory at addr = 0x%s "
+				    "len = %d.\n",
+				    OUTPUT_REG (tmpulongest, tdep->arg5),
+				    tdep->size_int);
+	      return -1;
+	    }
+	  regcache_raw_read_unsigned (regcache, tdep->arg4, &optvalp);
+	  tmpint = (int) extract_signed_integer (optlenp, tdep->size_int,
+						 byte_order);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) optvalp, tmpint))
+	    return -1;
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_int))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_socketcall:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       switch (tmpulongest)
-        {
-        case RECORD_SYS_SOCKET:
-        case RECORD_SYS_BIND:
-        case RECORD_SYS_CONNECT:
-        case RECORD_SYS_LISTEN:
-          break;
-        case RECORD_SYS_ACCEPT:
-        case RECORD_SYS_GETSOCKNAME:
-        case RECORD_SYS_GETPEERNAME:
-          {
-            regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                        &tmpulongest);
-            if (tmpulongest)
-              {
-                gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
-                ULONGEST len;
-
-                tmpulongest += tdep->size_ulong;
-                if (target_read_memory ((CORE_ADDR) tmpulongest, a,
-                                        tdep->size_ulong * 2))
-                  {
-                    if (record_debug)
-                      fprintf_unfiltered (gdb_stdlog,
-                                          "Process record: error reading "
-                                          "memory at addr = 0x%s len = %d.\n",
-                                          OUTPUT_REG (tmpulongest, tdep->arg2),
-                                          tdep->size_ulong * 2);
-                    return -1;
-                  }
-                tmpulongest = extract_unsigned_integer (a,
-                                                        tdep->size_ulong,
-                                                        byte_order);
-                len = extract_unsigned_integer (a + tdep->size_ulong,
-                                                tdep->size_ulong, byte_order);
-                if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
-                  return -1;
-              }
-          }
-          break;
-
-        case RECORD_SYS_SOCKETPAIR:
-          {
-            gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong);
-
-            regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                        &tmpulongest);
-            if (tmpulongest)
-              {
-                tmpulongest += tdep->size_ulong * 3;
-                if (target_read_memory ((CORE_ADDR) tmpulongest, a,
-                                        tdep->size_ulong))
-                  {
-                    if (record_debug)
-                      fprintf_unfiltered (gdb_stdlog,
-                                          "Process record: error reading "
-                                          "memory at addr = 0x%s len = %d.\n",
-                                          OUTPUT_REG (tmpulongest, tdep->arg2),
-                                          tdep->size_ulong);
-                    return -1;
-                  }
-                tmpaddr
-                  = (CORE_ADDR) extract_unsigned_integer (a, tdep->size_ulong,
-                                                          byte_order);
-                if (record_full_arch_list_add_mem (tmpaddr, tdep->size_int))
-                  return -1;
-              }
-          }
-          break;
-        case RECORD_SYS_SEND:
-        case RECORD_SYS_SENDTO:
-          break;
-        case RECORD_SYS_RECVFROM:
-          regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                      &tmpulongest);
-          if (tmpulongest)
-            {
-              gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
-              ULONGEST len;
-
-              tmpulongest += tdep->size_ulong * 4;
-              if (target_read_memory ((CORE_ADDR) tmpulongest, a,
-                                      tdep->size_ulong * 2))
-                {
-                  if (record_debug)
-                    fprintf_unfiltered (gdb_stdlog,
-                                        "Process record: error reading "
-                                        "memory at addr = 0x%s len = %d.\n",
-                                        OUTPUT_REG (tmpulongest, tdep->arg2),
-                                        tdep->size_ulong * 2);
-                  return -1;
-                }
-              tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
-                                                      byte_order);
-              len = extract_unsigned_integer (a + tdep->size_ulong,
-                                              tdep->size_ulong, byte_order);
-              if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
-                return -1;
-            }
-        case RECORD_SYS_RECV:
-          regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                      &tmpulongest);
-          if (tmpulongest)
-            {
-              gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
-
-              tmpulongest += tdep->size_ulong;
-              if (target_read_memory ((CORE_ADDR) tmpulongest, a,
-                                      tdep->size_ulong))
-                {
-                  if (record_debug)
-                    fprintf_unfiltered (gdb_stdlog,
-                                        "Process record: error reading "
-                                        "memory at addr = 0x%s len = %d.\n",
-                                        OUTPUT_REG (tmpulongest, tdep->arg2),
-                                        tdep->size_ulong);
-                  return -1;
-                }
-              tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
-                                                      byte_order);
-              if (tmpulongest)
-                {
-                  a += tdep->size_ulong;
-                  tmpint = (int) extract_unsigned_integer (a, tdep->size_ulong,
-                                                           byte_order);
-                  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	case RECORD_SYS_SOCKET:
+	case RECORD_SYS_BIND:
+	case RECORD_SYS_CONNECT:
+	case RECORD_SYS_LISTEN:
+	  break;
+	case RECORD_SYS_ACCEPT:
+	case RECORD_SYS_GETSOCKNAME:
+	case RECORD_SYS_GETPEERNAME:
+	  {
+	    regcache_raw_read_unsigned (regcache, tdep->arg2,
+					&tmpulongest);
+	    if (tmpulongest)
+	      {
+		gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
+		ULONGEST len;
+
+		tmpulongest += tdep->size_ulong;
+		if (target_read_memory ((CORE_ADDR) tmpulongest, a,
+					tdep->size_ulong * 2))
+		  {
+		    if (record_debug)
+		      fprintf_unfiltered (gdb_stdlog,
+					  "Process record: error reading "
+					  "memory at addr = 0x%s len = %d.\n",
+					  OUTPUT_REG (tmpulongest, tdep->arg2),
+					  tdep->size_ulong * 2);
+		    return -1;
+		  }
+		tmpulongest = extract_unsigned_integer (a,
+							tdep->size_ulong,
+							byte_order);
+		len = extract_unsigned_integer (a + tdep->size_ulong,
+						tdep->size_ulong, byte_order);
+		if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
+		  return -1;
+	      }
+	  }
+	  break;
+
+	case RECORD_SYS_SOCKETPAIR:
+	  {
+	    gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong);
+
+	    regcache_raw_read_unsigned (regcache, tdep->arg2,
+					&tmpulongest);
+	    if (tmpulongest)
+	      {
+		tmpulongest += tdep->size_ulong * 3;
+		if (target_read_memory ((CORE_ADDR) tmpulongest, a,
+					tdep->size_ulong))
+		  {
+		    if (record_debug)
+		      fprintf_unfiltered (gdb_stdlog,
+					  "Process record: error reading "
+					  "memory at addr = 0x%s len = %d.\n",
+					  OUTPUT_REG (tmpulongest, tdep->arg2),
+					  tdep->size_ulong);
+		    return -1;
+		  }
+		tmpaddr
+		  = (CORE_ADDR) extract_unsigned_integer (a, tdep->size_ulong,
+							  byte_order);
+		if (record_full_arch_list_add_mem (tmpaddr, tdep->size_int))
+		  return -1;
+	      }
+	  }
+	  break;
+	case RECORD_SYS_SEND:
+	case RECORD_SYS_SENDTO:
+	  break;
+	case RECORD_SYS_RECVFROM:
+	  regcache_raw_read_unsigned (regcache, tdep->arg2,
+				      &tmpulongest);
+	  if (tmpulongest)
+	    {
+	      gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
+	      ULONGEST len;
+
+	      tmpulongest += tdep->size_ulong * 4;
+	      if (target_read_memory ((CORE_ADDR) tmpulongest, a,
+				      tdep->size_ulong * 2))
+		{
+		  if (record_debug)
+		    fprintf_unfiltered (gdb_stdlog,
+					"Process record: error reading "
+					"memory at addr = 0x%s len = %d.\n",
+					OUTPUT_REG (tmpulongest, tdep->arg2),
+					tdep->size_ulong * 2);
+		  return -1;
+		}
+	      tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
+						      byte_order);
+	      len = extract_unsigned_integer (a + tdep->size_ulong,
+					      tdep->size_ulong, byte_order);
+	      if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
+		return -1;
+	    }
+	case RECORD_SYS_RECV:
+	  regcache_raw_read_unsigned (regcache, tdep->arg2,
+				      &tmpulongest);
+	  if (tmpulongest)
+	    {
+	      gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
+
+	      tmpulongest += tdep->size_ulong;
+	      if (target_read_memory ((CORE_ADDR) tmpulongest, a,
+				      tdep->size_ulong))
+		{
+		  if (record_debug)
+		    fprintf_unfiltered (gdb_stdlog,
+					"Process record: error reading "
+					"memory at addr = 0x%s len = %d.\n",
+					OUTPUT_REG (tmpulongest, tdep->arg2),
+					tdep->size_ulong);
+		  return -1;
+		}
+	      tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
+						      byte_order);
+	      if (tmpulongest)
+		{
+		  a += tdep->size_ulong;
+		  tmpint = (int) extract_unsigned_integer (a, tdep->size_ulong,
+							   byte_order);
+		  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 						     tmpint))
-                    return -1;
-                }
-            }
-          break;
-        case RECORD_SYS_SHUTDOWN:
-        case RECORD_SYS_SETSOCKOPT:
-          break;
-        case RECORD_SYS_GETSOCKOPT:
-          {
-            gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
-            gdb_byte *av = (gdb_byte *) alloca (tdep->size_int);
-
-            regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                        &tmpulongest);
-            if (tmpulongest)
-              {
-                tmpulongest += tdep->size_ulong * 3;
-                if (target_read_memory ((CORE_ADDR) tmpulongest, a,
-                                        tdep->size_ulong * 2))
-                  {
-                    if (record_debug)
-                      fprintf_unfiltered (gdb_stdlog,
-                                          "Process record: error reading "
-                                          "memory at addr = 0x%s len = %d.\n",
-                                          OUTPUT_REG (tmpulongest, tdep->arg2),
-                                          tdep->size_ulong * 2);
-                    return -1;
-                  }
-                tmpulongest = extract_unsigned_integer (a + tdep->size_ulong,
-                                                        tdep->size_ulong,
-                                                        byte_order);
-                if (tmpulongest)
-                  {
-                    if (target_read_memory ((CORE_ADDR) tmpulongest, av,
-                                            tdep->size_int))
-                      {
-                        if (record_debug)
-                          fprintf_unfiltered (gdb_stdlog,
-                                              "Process record: error reading "
-                                              "memory at addr = 0x%s "
-                                              "len = %d.\n",
-                                              phex_nz (tmpulongest,
-                                                       tdep->size_ulong),
-                                              tdep->size_int);
-                        return -1;
-                      }
-                    tmpaddr
-                      = (CORE_ADDR) extract_unsigned_integer (a,
-                                                              tdep->size_ulong,
-                                                              byte_order);
-                    tmpint = (int) extract_unsigned_integer (av,
-                                                             tdep->size_int,
-                                                             byte_order);
-                    if (record_full_arch_list_add_mem (tmpaddr, tmpint))
-                      return -1;
-                    a += tdep->size_ulong;
-                    tmpaddr
-                      = (CORE_ADDR) extract_unsigned_integer (a,
-                                                              tdep->size_ulong,
-                                                              byte_order);
-                    if (record_full_arch_list_add_mem (tmpaddr,
+		    return -1;
+		}
+	    }
+	  break;
+	case RECORD_SYS_SHUTDOWN:
+	case RECORD_SYS_SETSOCKOPT:
+	  break;
+	case RECORD_SYS_GETSOCKOPT:
+	  {
+	    gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
+	    gdb_byte *av = (gdb_byte *) alloca (tdep->size_int);
+
+	    regcache_raw_read_unsigned (regcache, tdep->arg2,
+					&tmpulongest);
+	    if (tmpulongest)
+	      {
+		tmpulongest += tdep->size_ulong * 3;
+		if (target_read_memory ((CORE_ADDR) tmpulongest, a,
+					tdep->size_ulong * 2))
+		  {
+		    if (record_debug)
+		      fprintf_unfiltered (gdb_stdlog,
+					  "Process record: error reading "
+					  "memory at addr = 0x%s len = %d.\n",
+					  OUTPUT_REG (tmpulongest, tdep->arg2),
+					  tdep->size_ulong * 2);
+		    return -1;
+		  }
+		tmpulongest = extract_unsigned_integer (a + tdep->size_ulong,
+							tdep->size_ulong,
+							byte_order);
+		if (tmpulongest)
+		  {
+		    if (target_read_memory ((CORE_ADDR) tmpulongest, av,
+					    tdep->size_int))
+		      {
+			if (record_debug)
+			  fprintf_unfiltered (gdb_stdlog,
+					      "Process record: error reading "
+					      "memory at addr = 0x%s "
+					      "len = %d.\n",
+					      phex_nz (tmpulongest,
+						       tdep->size_ulong),
+					      tdep->size_int);
+			return -1;
+		      }
+		    tmpaddr
+		      = (CORE_ADDR) extract_unsigned_integer (a,
+							      tdep->size_ulong,
+							      byte_order);
+		    tmpint = (int) extract_unsigned_integer (av,
+							     tdep->size_int,
+							     byte_order);
+		    if (record_full_arch_list_add_mem (tmpaddr, tmpint))
+		      return -1;
+		    a += tdep->size_ulong;
+		    tmpaddr
+		      = (CORE_ADDR) extract_unsigned_integer (a,
+							      tdep->size_ulong,
+							      byte_order);
+		    if (record_full_arch_list_add_mem (tmpaddr,
 						       tdep->size_int))
-                      return -1;
-                  }
-              }
-          }
-          break;
-        case RECORD_SYS_SENDMSG:
-          break;
-        case RECORD_SYS_RECVMSG:
-          {
-            gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong);
-
-            regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                        &tmpulongest);
-            if (tmpulongest)
-              {
-                tmpulongest += tdep->size_ulong;
-                if (target_read_memory ((CORE_ADDR) tmpulongest, a,
-                                        tdep->size_ulong))
-                  {
-                    if (record_debug)
-                      fprintf_unfiltered (gdb_stdlog,
-                                          "Process record: error reading "
-                                          "memory at addr = 0x%s len = %d.\n",
-                                          OUTPUT_REG (tmpulongest, tdep->arg2),
-                                          tdep->size_ulong);
-                    return -1;
-                  }
-                tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
-                                                        byte_order);
-                if (record_linux_msghdr (regcache, tdep, tmpulongest))
-                  return -1;
-              }
-          }
-          break;
-        default:
-          printf_unfiltered (_("Process record and replay target "
-                               "doesn't support socketcall call 0x%s\n"),
-                             OUTPUT_REG (tmpulongest, tdep->arg1));
-          return -1;
-          break;
-        }
+		      return -1;
+		  }
+	      }
+	  }
+	  break;
+	case RECORD_SYS_SENDMSG:
+	  break;
+	case RECORD_SYS_RECVMSG:
+	  {
+	    gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong);
+
+	    regcache_raw_read_unsigned (regcache, tdep->arg2,
+					&tmpulongest);
+	    if (tmpulongest)
+	      {
+		tmpulongest += tdep->size_ulong;
+		if (target_read_memory ((CORE_ADDR) tmpulongest, a,
+					tdep->size_ulong))
+		  {
+		    if (record_debug)
+		      fprintf_unfiltered (gdb_stdlog,
+					  "Process record: error reading "
+					  "memory at addr = 0x%s len = %d.\n",
+					  OUTPUT_REG (tmpulongest, tdep->arg2),
+					  tdep->size_ulong);
+		    return -1;
+		  }
+		tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
+							byte_order);
+		if (record_linux_msghdr (regcache, tdep, tmpulongest))
+		  return -1;
+	      }
+	  }
+	  break;
+	default:
+	  printf_unfiltered (_("Process record and replay target "
+			       "doesn't support socketcall call 0x%s\n"),
+			     OUTPUT_REG (tmpulongest, tdep->arg1));
+	  return -1;
+	  break;
+	}
       break;
 
     case gdb_sys_syslog:
@@ -1107,14 +1107,14 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_itimerval))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_getitimer:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_itimerval))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_newstat:
@@ -1123,21 +1123,21 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_stat))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_newfstatat:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_stat))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_uname:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_old_utsname))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_iopl:
@@ -1150,11 +1150,11 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_rusage))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_swapoff:
@@ -1164,7 +1164,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_sysinfo))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_shmget:
@@ -1181,14 +1181,14 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_ulong))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_shmctl:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_shmid_ds))
-        return -1;
+	return -1;
       break;
 
       /* XXX sys_semctl 525 still not supported.  */
@@ -1196,14 +1196,14 @@ Do you want to stop the program?"),
 
     case gdb_sys_msgrcv:
       {
-        ULONGEST msgp;
-        LONGEST l;
-
-        regcache_raw_read_signed (regcache, tdep->arg3, &l);
-        regcache_raw_read_unsigned (regcache, tdep->arg2, &msgp);
-        tmpint = l + tdep->size_long;
-        if (record_full_arch_list_add_mem ((CORE_ADDR) msgp, tmpint))
-          return -1;
+	ULONGEST msgp;
+	LONGEST l;
+
+	regcache_raw_read_signed (regcache, tdep->arg3, &l);
+	regcache_raw_read_unsigned (regcache, tdep->arg2, &msgp);
+	tmpint = l + tdep->size_long;
+	if (record_full_arch_list_add_mem ((CORE_ADDR) msgp, tmpint))
+	  return -1;
       }
       break;
 
@@ -1211,63 +1211,63 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_msqid_ds))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_ipc:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       tmpulongest &= 0xffff;
       switch (tmpulongest)
-        {
-        case RECORD_SEMOP:
-        case RECORD_SEMGET:
-        case RECORD_SEMTIMEDOP:
-        case RECORD_MSGSND:
-        case RECORD_MSGGET:
+	{
+	case RECORD_SEMOP:
+	case RECORD_SEMGET:
+	case RECORD_SEMTIMEDOP:
+	case RECORD_MSGSND:
+	case RECORD_MSGGET:
 	  /* XXX maybe need do some record works with RECORD_SHMDT.  */
-        case RECORD_SHMDT:
-        case RECORD_SHMGET:
-          break;
-        case RECORD_MSGRCV:
-          {
-            LONGEST second;
-            ULONGEST ptr;
-
-            regcache_raw_read_signed (regcache, tdep->arg3, &second);
-            regcache_raw_read_unsigned (regcache, tdep->arg5, &ptr);
-            tmpint = (int) second + tdep->size_long;
-            if (record_full_arch_list_add_mem ((CORE_ADDR) ptr, tmpint))
-              return -1;
-          }
-          break;
-        case RECORD_MSGCTL:
-          regcache_raw_read_unsigned (regcache, tdep->arg5,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	case RECORD_SHMDT:
+	case RECORD_SHMGET:
+	  break;
+	case RECORD_MSGRCV:
+	  {
+	    LONGEST second;
+	    ULONGEST ptr;
+
+	    regcache_raw_read_signed (regcache, tdep->arg3, &second);
+	    regcache_raw_read_unsigned (regcache, tdep->arg5, &ptr);
+	    tmpint = (int) second + tdep->size_long;
+	    if (record_full_arch_list_add_mem ((CORE_ADDR) ptr, tmpint))
+	      return -1;
+	  }
+	  break;
+	case RECORD_MSGCTL:
+	  regcache_raw_read_unsigned (regcache, tdep->arg5,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_msqid_ds))
-            return -1;
-          break;
-        case RECORD_SHMAT:
-          regcache_raw_read_unsigned (regcache, tdep->arg4,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	    return -1;
+	  break;
+	case RECORD_SHMAT:
+	  regcache_raw_read_unsigned (regcache, tdep->arg4,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_ulong))
-            return -1;
-          break;
-        case RECORD_SHMCTL:
-          regcache_raw_read_unsigned (regcache, tdep->arg5,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	    return -1;
+	  break;
+	case RECORD_SHMCTL:
+	  regcache_raw_read_unsigned (regcache, tdep->arg5,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_shmid_ds))
-            return -1;
-          break;
-        default:
+	    return -1;
+	  break;
+	default:
 	  /* XXX RECORD_SEMCTL still not supported.  */
-          printf_unfiltered (_("Process record and replay target doesn't "
-                               "support ipc number %s\n"), 
+	  printf_unfiltered (_("Process record and replay target doesn't "
+			       "support ipc number %s\n"),
 			     pulongest (tmpulongest));
-          break;
-        }
+	  break;
+	}
       break;
 
     case gdb_sys_fsync:
@@ -1280,27 +1280,27 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_new_utsname))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_modify_ldt:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest == 0 || tmpulongest == 2)
-        {
-          ULONGEST ptr, bytecount;
+	{
+	  ULONGEST ptr, bytecount;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg2, &ptr);
-          regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) ptr, (int) bytecount))
-            return -1;
-        }
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &ptr);
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) ptr, (int) bytecount))
+	    return -1;
+	}
       break;
 
     case gdb_sys_adjtimex:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_timex))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_mprotect:
@@ -1310,7 +1310,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_old_sigset_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_ni_syscall127:
@@ -1322,37 +1322,37 @@ Do you want to stop the program?"),
     case gdb_sys_quotactl:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       switch (tmpulongest)
-        {
-        case RECORD_Q_GETFMT:
-          regcache_raw_read_unsigned (regcache, tdep->arg4,
-                                      &tmpulongest);
-          /* __u32 */
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
-            return -1;
-          break;
-        case RECORD_Q_GETINFO:
-          regcache_raw_read_unsigned (regcache, tdep->arg4,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	case RECORD_Q_GETFMT:
+	  regcache_raw_read_unsigned (regcache, tdep->arg4,
+				      &tmpulongest);
+	  /* __u32 */
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
+	    return -1;
+	  break;
+	case RECORD_Q_GETINFO:
+	  regcache_raw_read_unsigned (regcache, tdep->arg4,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_mem_dqinfo))
-            return -1;
-          break;
-        case RECORD_Q_GETQUOTA:
-          regcache_raw_read_unsigned (regcache, tdep->arg4,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	    return -1;
+	  break;
+	case RECORD_Q_GETQUOTA:
+	  regcache_raw_read_unsigned (regcache, tdep->arg4,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_if_dqblk))
-            return -1;
-          break;
-        case RECORD_Q_XGETQSTAT:
-        case RECORD_Q_XGETQUOTA:
-          regcache_raw_read_unsigned (regcache, tdep->arg4,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	    return -1;
+	  break;
+	case RECORD_Q_XGETQSTAT:
+	case RECORD_Q_XGETQUOTA:
+	  regcache_raw_read_unsigned (regcache, tdep->arg4,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_fs_quota_stat))
-            return -1;
-          break;
-        }
+	    return -1;
+	  break;
+	}
       break;
 
     case gdb_sys_getpgid:
@@ -1363,13 +1363,13 @@ Do you want to stop the program?"),
     case gdb_sys_sysfs:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest == 2)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
 	  /*XXX the size of memory is not very clear.  */
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 10))
-            return -1;
-        }
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 10))
+	    return -1;
+	}
       break;
 
     case gdb_sys_personality:
@@ -1382,19 +1382,19 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_loff_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_getdents:
     case gdb_sys_getdents64:
       {
-        ULONGEST count;
+	ULONGEST count;
 
-        regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                    &tmpulongest);
-        regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
-        if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, count))
-          return -1;
+	regcache_raw_read_unsigned (regcache, tdep->arg2,
+				    &tmpulongest);
+	regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
+	if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, count))
+	  return -1;
       }
       break;
 
@@ -1402,19 +1402,19 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_fd_set))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_fd_set))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_fd_set))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_timeval))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_flock:
@@ -1423,40 +1423,40 @@ Do you want to stop the program?"),
 
     case gdb_sys_readv:
       {
-        ULONGEST vec, vlen;
-
-        regcache_raw_read_unsigned (regcache, tdep->arg2, &vec);
-        if (vec)
-          {
-            gdb_byte *iov = (gdb_byte *) alloca (tdep->size_iovec);
-
-            regcache_raw_read_unsigned (regcache, tdep->arg3, &vlen);
-            for (tmpulongest = 0; tmpulongest < vlen; tmpulongest++)
-              {
-                if (target_read_memory ((CORE_ADDR) vec, iov,
-                                        tdep->size_iovec))
-                  {
-                    if (record_debug)
-                      fprintf_unfiltered (gdb_stdlog,
-                                          "Process record: error reading "
-                                          "memory at addr = 0x%s len = %d.\n",
-                                          OUTPUT_REG (vec, tdep->arg2),
-                                          tdep->size_iovec);
-                    return -1;
-                  }
-                tmpaddr
-                  = (CORE_ADDR) extract_unsigned_integer (iov,
-                                                          tdep->size_pointer,
-                                                          byte_order);
-                tmpint
-                  = (int) extract_unsigned_integer (iov + tdep->size_pointer,
-                                                    tdep->size_size_t,
-                                                    byte_order);
-                if (record_full_arch_list_add_mem (tmpaddr, tmpint))
-                  return -1;
-                vec += tdep->size_iovec;
-              }
-          }
+	ULONGEST vec, vlen;
+
+	regcache_raw_read_unsigned (regcache, tdep->arg2, &vec);
+	if (vec)
+	  {
+	    gdb_byte *iov = (gdb_byte *) alloca (tdep->size_iovec);
+
+	    regcache_raw_read_unsigned (regcache, tdep->arg3, &vlen);
+	    for (tmpulongest = 0; tmpulongest < vlen; tmpulongest++)
+	      {
+		if (target_read_memory ((CORE_ADDR) vec, iov,
+					tdep->size_iovec))
+		  {
+		    if (record_debug)
+		      fprintf_unfiltered (gdb_stdlog,
+					  "Process record: error reading "
+					  "memory at addr = 0x%s len = %d.\n",
+					  OUTPUT_REG (vec, tdep->arg2),
+					  tdep->size_iovec);
+		    return -1;
+		  }
+		tmpaddr
+		  = (CORE_ADDR) extract_unsigned_integer (iov,
+							  tdep->size_pointer,
+							  byte_order);
+		tmpint
+		  = (int) extract_unsigned_integer (iov + tdep->size_pointer,
+						    tdep->size_size_t,
+						    byte_order);
+		if (record_full_arch_list_add_mem (tmpaddr, tmpint))
+		  return -1;
+		vec += tdep->size_iovec;
+	      }
+	  }
       }
       break;
 
@@ -1475,7 +1475,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_sched_setscheduler:
@@ -1490,7 +1490,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_timespec))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_mremap:
@@ -1501,15 +1501,15 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_old_uid_t))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_old_uid_t))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_old_uid_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_vm86:
@@ -1519,31 +1519,31 @@ Do you want to stop the program?"),
     case gdb_sys_poll:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST nfds;
+	{
+	  ULONGEST nfds;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_pollfd * nfds))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_nfsservctl:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest == 7 || tmpulongest == 8)
-        {
-          int rsize;
+	{
+	  int rsize;
 
-          if (tmpulongest == 7)
-            rsize = tdep->size_NFS_FHSIZE;
-          else
-            rsize = tdep->size_knfsd_fh;
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, rsize))
-            return -1;
-        }
+	  if (tmpulongest == 7)
+	    rsize = tdep->size_NFS_FHSIZE;
+	  else
+	    rsize = tdep->size_knfsd_fh;
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, rsize))
+	    return -1;
+	}
       break;
 
     case gdb_sys_setresgid16:
@@ -1553,36 +1553,36 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_old_gid_t))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_old_gid_t))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_old_gid_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_prctl:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       switch (tmpulongest)
-        {
-        case 2:
-          regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	case 2:
+	  regcache_raw_read_unsigned (regcache, tdep->arg2,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_int))
-            return -1;
-          break;
-        case 16:
-          regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	    return -1;
+	  break;
+	case 16:
+	  regcache_raw_read_unsigned (regcache, tdep->arg2,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_TASK_COMM_LEN))
-            return -1;
-          break;
-        }
+	    return -1;
+	  break;
+	}
       break;
 
     case gdb_sys_rt_sigreturn:
@@ -1592,34 +1592,34 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_sigaction))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_rt_sigprocmask:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_sigset_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_rt_sigpending:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST sigsetsize;
+	{
+	  ULONGEST sigsetsize;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     (int) sigsetsize))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_rt_sigtimedwait:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_siginfo_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_rt_sigqueueinfo:
@@ -1629,14 +1629,14 @@ Do you want to stop the program?"),
     case gdb_sys_pread64:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST count;
+	{
+	  ULONGEST count;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     (int) count))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_pwrite64:
@@ -1646,21 +1646,21 @@ Do you want to stop the program?"),
     case gdb_sys_getcwd:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST size;
+	{
+	  ULONGEST size;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     (int) size))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_capget:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_cap_user_data_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_capset:
@@ -1670,14 +1670,14 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_stack_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_sendfile:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_off_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_ni_syscall188:
@@ -1689,7 +1689,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_rlimit))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_mmap2:
@@ -1705,7 +1705,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_stat64))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_lchown:
@@ -1720,15 +1720,15 @@ Do you want to stop the program?"),
     case gdb_sys_getgroups:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST gidsetsize;
+	{
+	  ULONGEST gidsetsize;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg1,
-                                      &gidsetsize);
-          tmpint = tdep->size_gid_t * (int) gidsetsize;
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
-            return -1;
-        }
+	  regcache_raw_read_unsigned (regcache, tdep->arg1,
+				      &gidsetsize);
+	  tmpint = tdep->size_gid_t * (int) gidsetsize;
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
+	    return -1;
+	}
       break;
 
     case gdb_sys_setgroups:
@@ -1740,15 +1740,15 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_uid_t))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_uid_t))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_uid_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_setresgid:
@@ -1758,15 +1758,15 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_gid_t))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_gid_t))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_gid_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_chown:
@@ -1781,7 +1781,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_PAGE_SIZE))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_madvise:
@@ -1790,18 +1790,18 @@ Do you want to stop the program?"),
     case gdb_sys_fcntl64:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest == tdep->fcntl_F_GETLK64)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_flock64))
-            return -1;
-        }
+	    return -1;
+	}
       else if (tmpulongest != tdep->fcntl_F_SETLK64
-               && tmpulongest != tdep->fcntl_F_SETLKW64)
-        {
-          goto sys_fcntl;
-        }
+	       && tmpulongest != tdep->fcntl_F_SETLKW64)
+	{
+	  goto sys_fcntl;
+	}
       break;
 
     case gdb_sys_ni_syscall222:
@@ -1818,14 +1818,14 @@ Do you want to stop the program?"),
     case gdb_sys_fgetxattr:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST size;
+	{
+	  ULONGEST size;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     (int) size))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_listxattr:
@@ -1833,14 +1833,14 @@ Do you want to stop the program?"),
     case gdb_sys_flistxattr:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST size;
+	{
+	  ULONGEST size;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     (int) size))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_removexattr:
@@ -1853,7 +1853,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_loff_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_futex:
@@ -1863,35 +1863,35 @@ Do you want to stop the program?"),
     case gdb_sys_sched_getaffinity:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST len;
+	{
+	  ULONGEST len;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     (int) len))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_set_thread_area:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_get_thread_area:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_user_desc))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_io_setup:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_long))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_io_destroy:
@@ -1900,54 +1900,54 @@ Do you want to stop the program?"),
     case gdb_sys_io_getevents:
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST nr;
+	{
+	  ULONGEST nr;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg3, &nr);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &nr);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     nr * tdep->size_io_event))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_io_submit:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST nr, i;
-          gdb_byte *iocbp;
-
-          regcache_raw_read_unsigned (regcache, tdep->arg2, &nr);
-          iocbp = (gdb_byte *) alloca (nr * tdep->size_pointer);
-          if (target_read_memory ((CORE_ADDR) tmpulongest, iocbp,
-                                  nr * tdep->size_pointer))
-            {
-              if (record_debug)
-                fprintf_unfiltered (gdb_stdlog,
-                                    "Process record: error reading memory "
-                                    "at addr = 0x%s len = %u.\n",
-                                    OUTPUT_REG (tmpulongest, tdep->arg2),
-                                    (int) (nr * tdep->size_pointer));
-              return -1;
-            }
-          for (i = 0; i < nr; i++)
-            {
-              tmpaddr
-                = (CORE_ADDR) extract_unsigned_integer (iocbp,
-                                                        tdep->size_pointer,
-                                                        byte_order);
-              if (record_full_arch_list_add_mem (tmpaddr, tdep->size_iocb))
-                return -1;
-              iocbp += tdep->size_pointer;
-            }
-        }
+	{
+	  ULONGEST nr, i;
+	  gdb_byte *iocbp;
+
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &nr);
+	  iocbp = (gdb_byte *) alloca (nr * tdep->size_pointer);
+	  if (target_read_memory ((CORE_ADDR) tmpulongest, iocbp,
+				  nr * tdep->size_pointer))
+	    {
+	      if (record_debug)
+		fprintf_unfiltered (gdb_stdlog,
+				    "Process record: error reading memory "
+				    "at addr = 0x%s len = %u.\n",
+				    OUTPUT_REG (tmpulongest, tdep->arg2),
+				    (int) (nr * tdep->size_pointer));
+	      return -1;
+	    }
+	  for (i = 0; i < nr; i++)
+	    {
+	      tmpaddr
+		= (CORE_ADDR) extract_unsigned_integer (iocbp,
+							tdep->size_pointer,
+							byte_order);
+	      if (record_full_arch_list_add_mem (tmpaddr, tdep->size_iocb))
+		return -1;
+	      iocbp += tdep->size_pointer;
+	    }
+	}
       break;
 
     case gdb_sys_io_cancel:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_io_event))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_fadvise64:
@@ -1956,29 +1956,29 @@ Do you want to stop the program?"),
 
     case gdb_sys_exit_group:
       {
-        int q;
-
-        target_terminal_ours ();
-        q = yquery (_("The next instruction is syscall exit_group.  "
-                      "It will make the program exit.  "
-                      "Do you want to stop the program?"));
-        target_terminal_inferior ();
-        if (q)
-          return 1;
+	int q;
+
+	target_terminal_ours ();
+	q = yquery (_("The next instruction is syscall exit_group.  "
+		      "It will make the program exit.  "
+		      "Do you want to stop the program?"));
+	target_terminal_inferior ();
+	if (q)
+	  return 1;
       }
       break;
 
     case gdb_sys_lookup_dcookie:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST len;
+	{
+	  ULONGEST len;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     (int) len))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_epoll_create:
@@ -1988,15 +1988,15 @@ Do you want to stop the program?"),
     case gdb_sys_epoll_wait:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST maxevents;
+	{
+	  ULONGEST maxevents;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     (maxevents
 					      * tdep->size_epoll_event)))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_remap_file_pages:
@@ -2007,21 +2007,21 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_timer_settime:
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_itimerspec))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_timer_gettime:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_itimerspec))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_timer_getoverrun:
@@ -2033,21 +2033,21 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_timespec))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_clock_getres:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_timespec))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_clock_nanosleep:
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_timespec))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_statfs64:
@@ -2055,7 +2055,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_statfs64))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_tgkill:
@@ -2069,17 +2069,17 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST maxnode;
+	{
+	  ULONGEST maxnode;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     maxnode * tdep->size_long))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_set_mempolicy:
@@ -2091,18 +2091,18 @@ Do you want to stop the program?"),
     case gdb_sys_mq_timedreceive:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST msg_len;
+	{
+	  ULONGEST msg_len;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     (int) msg_len))
-            return -1;
-        }
+	    return -1;
+	}
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_mq_notify:
@@ -2112,7 +2112,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_mq_attr))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_kexec_load:
@@ -2122,11 +2122,11 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_siginfo_t))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_rusage))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_ni_syscall285:
@@ -2137,19 +2137,19 @@ Do you want to stop the program?"),
     case gdb_sys_keyctl:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest == 6 || tmpulongest == 11)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (tmpulongest)
-            {
-              ULONGEST buflen;
-
-              regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
-              if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	{
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+				      &tmpulongest);
+	  if (tmpulongest)
+	    {
+	      ULONGEST buflen;
+
+	      regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
+	      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 						 (int) buflen))
-                return -1;
-            }
-        }
+		return -1;
+	    }
+	}
       break;
 
     case gdb_sys_ioprio_set:
@@ -2169,7 +2169,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_stat64))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_unlinkat:
@@ -2181,14 +2181,14 @@ Do you want to stop the program?"),
     case gdb_sys_readlinkat:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST bufsiz;
+	{
+	  ULONGEST bufsiz;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     (int) bufsiz))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_fchmodat:
@@ -2199,36 +2199,36 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_fd_set))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_fd_set))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_fd_set))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_timespec))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_ppoll:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST nfds;
+	{
+	  ULONGEST nfds;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     tdep->size_pollfd * nfds))
-            return -1;
-        }
+	    return -1;
+	}
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_timespec))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_unshare:
@@ -2239,22 +2239,22 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_splice:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_loff_t))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_loff_t))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_sync_file_range:
@@ -2265,42 +2265,42 @@ Do you want to stop the program?"),
     case gdb_sys_move_pages:
       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST nr_pages;
+	{
+	  ULONGEST nr_pages;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages);
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages);
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					     nr_pages * tdep->size_int))
-            return -1;
-        }
+	    return -1;
+	}
       break;
 
     case gdb_sys_getcpu:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int))
-        return -1;
+	return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_ulong * 2))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_epoll_pwait:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST maxevents;
+	{
+	  ULONGEST maxevents;
 
-          regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
-          tmpint = (int) maxevents * tdep->size_epoll_event;
-          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
-            return -1;
-        }
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
+	  tmpint = (int) maxevents * tdep->size_epoll_event;
+	  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
+	    return -1;
+	}
       break;
 
     case gdb_sys_fallocate:
@@ -2313,7 +2313,7 @@ Do you want to stop the program?"),
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 					 tdep->size_int * 2))
-        return -1;
+	return -1;
       break;
 
     case gdb_sys_inotify_init1:
@@ -2321,7 +2321,7 @@ Do you want to stop the program?"),
 
     default:
       printf_unfiltered (_("Process record and replay target doesn't "
-                           "support syscall number %d\n"), syscall);
+			   "support syscall number %d\n"), syscall);
       return -1;
       break;
     }
