* serial.h (SERIAL_SET_TTY_STATE): Comment return value.

[deliverable/binutils-gdb.git] / gdb / rs6000-tdep.c

diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c
index e783c1e4e430766696e2fe0449c15e0d061eb948..fd68f53d508a25f91e67767872a3c8022bb6cd32 100644 (file)
--- a/gdb/rs6000-tdep.c
+++ b/gdb/rs6000-tdep.c
@@ -187,12 +187,13 @@ single_step (signal)
 skip_prologue (pc)
 CORE_ADDR pc;
 {
+  char buf[4];
   unsigned int tmp;
-  unsigned int op;    /* FIXME, assumes instruction size matches host int!!! */
+  unsigned long op;
 
-  if (target_read_memory (pc, (char *)&op, sizeof (op)))
+  if (target_read_memory (pc, buf, 4))
     return pc;                 /* Can't access it -- assume no prologue. */
-  SWAP_TARGET_AND_HOST (&op, sizeof (op));
+  op = extract_unsigned_integer (buf, 4);
 
   /* Assume that subsequent fetches can fail with low probability.  */
 
@@ -644,7 +645,7 @@ function_frame_info (pc, fdata)
     if (tmp == 0x93e1) {
       if (fdata->offset)
 /*        fatal ("Unrecognized prolog."); */
-        printf ("Unrecognized prolog!\n");
+        printf_unfiltered ("Unrecognized prolog!\n");
 
       fdata->saved_gpr = 31;
       tmp2 = op & 0xffff;
@@ -718,7 +719,7 @@ push_arguments (nargs, args, sp, struct_return, struct_addr)
   CORE_ADDR saved_sp, pc;
 
   if ( dummy_frame_count <= 0)
-    printf ("FATAL ERROR -push_arguments()! frame not found!!\n");
+    printf_unfiltered ("FATAL ERROR -push_arguments()! frame not found!!\n");
 
   /* The first eight words of ther arguments are passed in registers. Copy
      them appropriately.
@@ -742,11 +743,11 @@ push_arguments (nargs, args, sp, struct_return, struct_addr)
          there is no way we would run out of them. */
 
       if (len > 8)
-        printf (
+        printf_unfiltered (
 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 
-      bcopy (VALUE_CONTENTS (arg), 
-         &registers[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], len);
+      memcpy (&registers[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], VALUE_CONTENTS (arg), 
+         len);
       ++f_argno;
     }
 
@@ -756,8 +757,8 @@ push_arguments (nargs, args, sp, struct_return, struct_addr)
       while (argbytes < len) {
 
        *(int*)&registers[REGISTER_BYTE(ii+3)] = 0;
-       bcopy ( ((char*)VALUE_CONTENTS (arg))+argbytes, 
-                       &registers[REGISTER_BYTE(ii+3)], 
+       memcpy (&registers[REGISTER_BYTE(ii+3)], 
+                        ((char*)VALUE_CONTENTS (arg))+argbytes, 
                        (len - argbytes) > 4 ? 4 : len - argbytes);
        ++ii, argbytes += 4;
 
@@ -769,7 +770,7 @@ push_arguments (nargs, args, sp, struct_return, struct_addr)
     }
     else {        /* Argument can fit in one register. No problem. */
       *(int*)&registers[REGISTER_BYTE(ii+3)] = 0;
-      bcopy (VALUE_CONTENTS (arg), &registers[REGISTER_BYTE(ii+3)], len);
+      memcpy (&registers[REGISTER_BYTE(ii+3)], VALUE_CONTENTS (arg), len);
     }
     ++argno;
   }
@@ -833,11 +834,11 @@ ran_out_of_registers_for_arguments:
       if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_FLT && f_argno < 13) {
 
         if (len > 8)
-          printf (
+          printf_unfiltered (
 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 
-        bcopy (VALUE_CONTENTS (arg), 
-           &registers[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], len);
+        memcpy (&registers[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], VALUE_CONTENTS (arg), 
+           len);
         ++f_argno;
       }
 
@@ -877,17 +878,17 @@ extract_return_value (valtype, regbuf, valbuf)
        necessary. */
 
     if (TYPE_LENGTH (valtype) > 4)             /* this is a double */
-      bcopy (&regbuf[REGISTER_BYTE (FP0_REGNUM + 1)], valbuf, 
+      memcpy (valbuf, &regbuf[REGISTER_BYTE (FP0_REGNUM + 1)],
                                                TYPE_LENGTH (valtype));
     else {             /* float */
-      bcopy (&regbuf[REGISTER_BYTE (FP0_REGNUM + 1)], &dd, 8);
+      memcpy (&dd, &regbuf[REGISTER_BYTE (FP0_REGNUM + 1)], 8);
       ff = (float)dd;
-      bcopy (&ff, valbuf, sizeof(float));
+      memcpy (valbuf, &ff, sizeof(float));
     }
   }
   else
     /* return value is copied starting from r3. */
-    bcopy (&regbuf[REGISTER_BYTE (3)], valbuf, TYPE_LENGTH (valtype));
+    memcpy (valbuf, &regbuf[REGISTER_BYTE (3)], TYPE_LENGTH (valtype));
 }
 
 
@@ -948,6 +949,8 @@ int pcsaved;
 
   if (fi->next != NULL)
     /* Don't even think about framelessness except on the innermost frame.  */
+    /* FIXME: Can also be frameless if fi->next->signal_handler_caller (if
+       a signal happens while executing in a frameless function).  */
     return 0;
   
   func_start = get_pc_function_start (fi->pc) + FUNCTION_START_OFFSET;
@@ -986,7 +989,7 @@ frame_get_cache_fsr (fi, fdatap)
 
   fi->cache_fsr = (struct frame_saved_regs *)
       obstack_alloc (&frame_cache_obstack, sizeof (struct frame_saved_regs));
-  bzero (fi->cache_fsr, sizeof (struct frame_saved_regs));
+  memset (fi->cache_fsr, '\0', sizeof (struct frame_saved_regs));
 
   if (fi->prev && fi->prev->frame)
     frame_addr = fi->prev->frame;