← Back to branch summary

~ubuntu-branches/ubuntu/karmic/insight/karmic

« back to all changes in this revision

Viewing changes to gdb/remote-m32r-sdi.c

  • Committer: Bazaar Package Importer
  • Author(s): Masayuki Hatta (mhatta)
  • Date: 2007-12-04 22:37:09 UTC
  • mfrom: (1.2.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20071204223709-jxj396d1ox92s8ox
Tags: 6.7.1.dfsg.1-1
http://bugs.debian.org/314037
* New upstream release.
* This typo has been fixed in the upstream - closes: #314037.
* Removed non-free documents (GFDL'd with Invariant Sections, etc.).

Show diffs side-by-side

added added

removed removed

Lines of Context:
gdb/remote-m32r-sdi.c
1
1
/* Remote debugging interface for M32R/SDI.
2
2
 
3
 
   Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
 
3
   Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
4
4
 
5
5
   Contributed by Renesas Technology Co.
6
6
   Written by Kei Sakamoto <sakamoto.kei@renesas.com>.
9
9
 
10
10
   This program is free software; you can redistribute it and/or modify
11
11
   it under the terms of the GNU General Public License as published by
12
 
   the Free Software Foundation; either version 2 of the License, or
 
12
   the Free Software Foundation; either version 3 of the License, or
13
13
   (at your option) any later version.
14
14
 
15
15
   This program is distributed in the hope that it will be useful,
18
18
   GNU General Public License for more details.
19
19
 
20
20
   You should have received a copy of the GNU General Public License
21
 
   along with this program; if not, write to the Free Software
22
 
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
23
 
   Boston, MA 02110-1301, USA.  */
 
21
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
24
22
 
25
23
#include "defs.h"
26
24
#include "gdbcmd.h"
475
473
      else
476
474
        {
477
475
          buf[0] = SDI_WRITE_MEMORY;
478
 
          if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 
476
          if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
479
477
            store_long_parameter (buf + 1, pc_addr);
480
478
          else
481
479
            store_long_parameter (buf + 1, pc_addr - 1);
515
513
        continue;
516
514
 
517
515
      /* Set PBP. */
518
 
      if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 
516
      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
519
517
        send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
520
518
                            0x00000006);
521
519
      else
542
540
      store_long_parameter (buf + 5, 4);
543
541
      if ((bp_addr & 2) == 0 && bp_addr != (pc_addr & 0xfffffffc))
544
542
        {
545
 
          if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 
543
          if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
546
544
            {
547
545
              buf[9] = dbt_bp_entry[0];
548
546
              buf[10] = dbt_bp_entry[1];
559
557
        }
560
558
      else
561
559
        {
562
 
          if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 
560
          if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
563
561
            {
564
562
              if ((bp_addr & 2) == 0)
565
563
                {
606
604
        continue;
607
605
 
608
606
      /* DBC register */
609
 
      if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 
607
      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
610
608
        {
611
609
          switch (ab_type[i])
612
610
            {
747
745
  if (last_pc_addr != 0xffffffff)
748
746
    {
749
747
      buf[0] = SDI_WRITE_MEMORY;
750
 
      if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 
748
      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
751
749
        store_long_parameter (buf + 1, last_pc_addr);
752
750
      else
753
751
        store_long_parameter (buf + 1, last_pc_addr - 1);
776
774
             address, we have to take care of it later. */
777
775
          if ((pc_addr & 0x2) != 0)
778
776
            {
779
 
              if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 
777
              if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
780
778
                {
781
779
                  if ((bp_data[i][2] & 0x80) != 0)
782
780
                    {
838
836
          c = serial_readchar (sdi_desc, SDI_TIMEOUT);
839
837
          if (c != '-' && recv_data (buf, 4) != -1)
840
838
            {
841
 
              if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 
839
              if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
842
840
                {
843
841
                  if ((buf[3] & 0x1) == 0x1)
844
842
                    hit_watchpoint_addr = ab_address[i];
903
901
 
904
902
/* Read the remote registers into the block REGS.  */
905
903
 
906
 
static void m32r_fetch_register (int);
 
904
static void m32r_fetch_register (struct regcache *, int);
907
905
 
908
906
static void
909
 
m32r_fetch_registers (void)
 
907
m32r_fetch_registers (struct regcache *regcache)
910
908
{
911
909
  int regno;
912
910
 
913
 
  for (regno = 0; regno < NUM_REGS; regno++)
914
 
    m32r_fetch_register (regno);
 
911
  for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++)
 
912
    m32r_fetch_register (regcache, regno);
915
913
}
916
914
 
917
915
/* Fetch register REGNO, or all registers if REGNO is -1.
918
916
   Returns errno value.  */
919
917
static void
920
 
m32r_fetch_register (int regno)
 
918
m32r_fetch_register (struct regcache *regcache, int regno)
921
919
{
922
920
  unsigned long val, val2, regid;
923
921
 
924
922
  if (regno == -1)
925
 
    m32r_fetch_registers ();
 
923
    m32r_fetch_registers (regcache);
926
924
  else
927
925
    {
928
926
      char buffer[MAX_REGISTER_SIZE];
935
933
        {
936
934
          send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
937
935
          val2 = recv_long_data ();
938
 
          val = ((0x00c1 & val2) << 8) | ((0xc100 & val) >> 8);
 
936
          val = ((0x00cf & val2) << 8) | ((0xcf00 & val) >> 8);
939
937
        }
940
938
 
941
939
      if (remote_debug)
945
943
      /* We got the number the register holds, but gdb expects to see a
946
944
         value in the target byte ordering.  */
947
945
      store_unsigned_integer (buffer, 4, val);
948
 
      regcache_raw_supply (current_regcache, regno, buffer);
 
946
      regcache_raw_supply (regcache, regno, buffer);
949
947
    }
950
948
  return;
951
949
}
952
950
 
953
951
/* Store the remote registers from the contents of the block REGS.  */
954
952
 
955
 
static void m32r_store_register (int);
 
953
static void m32r_store_register (struct regcache *, int);
956
954
 
957
955
static void
958
 
m32r_store_registers (void)
 
956
m32r_store_registers (struct regcache *regcache)
959
957
{
960
958
  int regno;
961
959
 
962
 
  for (regno = 0; regno < NUM_REGS; regno++)
963
 
    m32r_store_register (regno);
 
960
  for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++)
 
961
    m32r_store_register (regcache, regno);
964
962
 
965
963
  registers_changed ();
966
964
}
968
966
/* Store register REGNO, or all if REGNO == 0.
969
967
   Return errno value.  */
970
968
static void
971
 
m32r_store_register (int regno)
 
969
m32r_store_register (struct regcache *regcache, int regno)
972
970
{
973
971
  int regid;
974
972
  ULONGEST regval, tmp;
975
973
 
976
974
  if (regno == -1)
977
 
    m32r_store_registers ();
 
975
    m32r_store_registers (regcache);
978
976
  else
979
977
    {
980
 
      regcache_cooked_read_unsigned (current_regcache, regno, &regval);
 
978
      regcache_cooked_read_unsigned (regcache, regno, &regval);
981
979
      regid = get_reg_id (regno);
982
980
 
983
981
      if (regid == SDI_REG_PSW)
990
988
          send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
991
989
          bbpsw = recv_long_data ();
992
990
 
993
 
          tmp = (0x00c1 & psw) | ((0x00c1 & regval) << 8);
 
991
          tmp = (0x00cf & psw) | ((0x00cf & regval) << 8);
994
992
          send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PSW, tmp);
995
993
 
996
 
          tmp = (0x0030 & bbpsw) | ((0xc100 & regval) >> 8);
 
994
          tmp = (0x0030 & bbpsw) | ((0xcf00 & regval) >> 8);
997
995
          send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BBPSW, tmp);
998
996
        }
999
997
      else
1014
1012
   debugged.  */
1015
1013
 
1016
1014
static void
1017
 
m32r_prepare_to_store (void)
 
1015
m32r_prepare_to_store (struct regcache *regcache)
1018
1016
{
1019
1017
  /* Do nothing, since we can store individual regs */
1020
1018
  if (remote_debug)