Merge GDB 7.5.1

sim/cr16/simops.c

 /* Simulation code for the CR16 processor.
    Copyright (C) 2008-2012 Free Software Foundation, Inc.
    Contributed by M Ranga Swami Reddy <MR.Swami.Reddy@nsc.com>
 
    This file is part of GDB, the GNU debugger.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3, or (at your option)
    any later version.
@@ skipping 5113 matching lines @@
 #define RETVAL32(X) do { result = (X); SET_GPR32 (0, result);} while (0)
 #define RETERR(X) SET_GPR (4, (X))              /* return error code.  */
 
 /* Turn a pointer in a register into a pointer into real memory. */
 
 #define MEMPTR(x) ((char *)(dmem_addr(x)))
 
         switch (FUNC)
           {
 #if !defined(__GO32__) && !defined(_WIN32)
+#ifdef TARGET_SYS_fork
           case TARGET_SYS_fork:
             trace_input ("<fork>", OP_VOID, OP_VOID, OP_VOID);
             RETVAL (fork ());
             trace_output_16 (result);
             break;
+#endif
 
 #define getpid() 47
           case TARGET_SYS_getpid:
             trace_input ("<getpid>", OP_VOID, OP_VOID, OP_VOID);
             RETVAL (getpid ());
             trace_output_16 (result);
             break;
 
           case TARGET_SYS_kill:
             trace_input ("<kill>", OP_REG, OP_REG, OP_VOID);
@@ skipping 116 matching lines @@
                     State.exception = SIGILL;
                   }
                 else
                   {
                     RETVAL (kill (PARM1, PARM2));
                     trace_output_16 (result);
                   }
               }
             break;
 
+#ifdef TARGET_SYS_execve
           case TARGET_SYS_execve:
             trace_input ("<execve>", OP_VOID, OP_VOID, OP_VOID);
             RETVAL (execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2<<16|PARM3),
                              (char **)MEMPTR (PARM4)));
             trace_output_16 (result);
             break;
+#endif
 
 #ifdef TARGET_SYS_execv
           case TARGET_SYS_execv:
             trace_input ("<execv>", OP_VOID, OP_VOID, OP_VOID);
             RETVAL (execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2), NULL));
             trace_output_16 (result);
             break;
 #endif
 
+#ifdef TARGET_SYS_pipe
           case TARGET_SYS_pipe:
             {
               reg_t buf;
               int host_fd[2];
 
               trace_input ("<pipe>", OP_VOID, OP_VOID, OP_VOID);
               buf = PARM1;
               RETVAL (pipe (host_fd));
               SW (buf, host_fd[0]);
               buf += sizeof(uint16);
               SW (buf, host_fd[1]);
               trace_output_16 (result);
             }
           break;
+#endif
 
 #ifdef TARGET_SYS_wait
           case TARGET_SYS_wait:
             {
               int status;
               trace_input ("<wait>", OP_REG, OP_VOID, OP_VOID);
               RETVAL (wait (&status));
               if (PARM1)
                 SW (PARM1, status);
               trace_output_16 (result);
@@ skipping 44 matching lines @@
             break;
 
           case TARGET_SYS_open:
             trace_input ("<open>", OP_MEMREF, OP_REG, OP_VOID);
             RETVAL32 (cr16_callback->open (cr16_callback, 
                                  MEMPTR ((((unsigned long)PARM2)<<16)|PARM1), 
                                  PARM3));
             trace_output_32 (result);
             break;
 
+#ifdef TARGET_SYS_rename
           case TARGET_SYS_rename:
             trace_input ("<rename>", OP_MEMREF, OP_MEMREF, OP_VOID);
             RETVAL (cr16_callback->rename (cr16_callback, 
                                    MEMPTR ((((unsigned long)PARM2)<<16) |PARM1),
                                    MEMPTR ((((unsigned long)PARM4)<<16) |PARM3)));
             trace_output_16 (result);
             break;
+#endif
 
           case 0x408: /* REVISIT: Added a dummy getenv call. */
             trace_input ("<getenv>", OP_MEMREF, OP_MEMREF, OP_VOID);
             RETVAL32(NULL);
             trace_output_32 (result);
             break;
 
           case TARGET_SYS_exit:
             trace_input ("<exit>", OP_VOID, OP_VOID, OP_VOID);
             State.exception = SIG_CR16_EXIT;
@@ skipping 32 matching lines @@
               SW  (buf+12, host_stat.st_rdev);
               SLW (buf+16, host_stat.st_size);
               SLW (buf+20, host_stat.st_atime);
               SLW (buf+28, host_stat.st_mtime);
               SLW (buf+36, host_stat.st_ctime);
             }
             trace_output_16 (result);
             break;
 #endif
 
+#ifdef TARGET_SYS_chown
           case TARGET_SYS_chown:
             trace_input ("<chown>", OP_VOID, OP_VOID, OP_VOID);
             RETVAL (chown (MEMPTR (PARM1), PARM2, PARM3));
             trace_output_16 (result);
             break;
+#endif
 
           case TARGET_SYS_chmod:
             trace_input ("<chmod>", OP_VOID, OP_VOID, OP_VOID);
             RETVAL (chmod (MEMPTR (PARM1), PARM2));
             trace_output_16 (result);
             break;
 
 #ifdef TARGET_SYS_utime
           case TARGET_SYS_utime:
             trace_input ("<utime>", OP_REG, OP_REG, OP_REG);
@@ skipping 524 matching lines @@
   trace_output_32 (a);
 }
 
 /* null.  */
 void
 OP_0_20 ()
 {
   trace_input ("null", OP_VOID, OP_VOID, OP_VOID);
   State.exception = SIG_CR16_STOP;
 }