gdb-6.3-ia64-sigtramp-frame-20050708.patch

   1 2005-07-08  Jeff Johnston  <jjohnstn@redhat.com>
   2
   3         * ia64-tdep.c (ia64_sigtramp_frame_prev_register): Build
   4         pseudo-registers the same as ia64_pseudo_register_read.
   5
   6 2008-04-16  Yi Zhan  <yi.zhan@intel.com>
   7
   8         * ia64-tdep.c (ia64_sigtramp_frame_prev_register): Fix an
   9         ISO C compliance compilation error.
  10
  11 2008-02-12  Jan Kratochvil  <jan.kratochvil@redhat.com>
  12
  13         Port to gdb-6.8.50.20081128, follow the upstream change:
  14         http://sourceware.org/cgi-bin/cvsweb.cgi/src/gdb/ia64-tdep.c.diff?cvsroot=src&r1=1.176&r2=1.177
  15
  16 Index: gdb-6.8.50.20081128/gdb/ia64-tdep.c
  17 ===================================================================
  18 --- gdb-6.8.50.20081128.orig/gdb/ia64-tdep.c    2008-11-26 06:27:48.000000000 +0100
  19 +++ gdb-6.8.50.20081128/gdb/ia64-tdep.c 2008-12-02 19:04:32.000000000 +0100
  20 @@ -2107,6 +2107,94 @@ ia64_sigtramp_frame_prev_register (struc
  21        return frame_unwind_got_constant (this_frame, regnum, pc);
  22      }
  23
  24 +  /* Red Hat patch begin.  */
  25 +  else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
  26 +    {
  27 +      /* NAT pseudo registers 0-31: get them from UNAT.
  28 +       * "copied" from ia64_pseudo_register_read() */
  29 +      ULONGEST unatN_val;
  30 +      ULONGEST unat;
  31 +      read_memory (cache->saved_regs[IA64_UNAT_REGNUM], (char *) &unat,
  32 +                  register_size (current_gdbarch, IA64_UNAT_REGNUM));
  33 +      unatN_val = (unat & (1LL << (regnum - IA64_NAT0_REGNUM))) != 0;
  34 +      return frame_unwind_got_constant (this_frame, regnum, unatN_val);
  35 +    }
  36 +  else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
  37 +    {
  38 +      /* NAT pseudo registers 32-127.
  39 +       * "copied" from ia64_pseudo_register_read()
  40 +       * FIXME: Not currently tested -- cannot get the frame to include
  41 +       *        NAT32-NAT127.  */
  42 +      ULONGEST bsp;
  43 +      ULONGEST cfm;
  44 +      ULONGEST natN_val = 0;
  45 +      CORE_ADDR gr_addr = 0, nat_addr = 0;
  46 +
  47 +      read_memory (cache->saved_regs[IA64_BSP_REGNUM], (char *) &bsp,
  48 +                  register_size (current_gdbarch, IA64_BSP_REGNUM));
  49 +      read_memory (cache->saved_regs[IA64_CFM_REGNUM], (char *) &cfm,
  50 +                  register_size (current_gdbarch, IA64_CFM_REGNUM));
  51 +
  52 +      /* The bsp points at the end of the register frame so we
  53 +        subtract the size of frame from it to get start of register frame.  */
  54 +      bsp = rse_address_add (bsp, -(cfm & 0x7f));
  55 +
  56 +      if ((cfm & 0x7f) > regnum - V32_REGNUM)
  57 +       gr_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
  58 +
  59 +      if (gr_addr != 0)
  60 +       {
  61 +         /* Compute address of nat collection bits */
  62 +         CORE_ADDR nat_collection;
  63 +         int nat_bit;
  64 +         nat_addr = gr_addr | 0x1f8;
  65 +         /* If our nat collection address is bigger than bsp, we have to get
  66 +            the nat collection from rnat.  Otherwise, we fetch the nat
  67 +            collection from the computed address. FIXME: Do not know if
  68 +            RNAT can be not stored in the frame--being extra cautious. */
  69 +         if (nat_addr >= bsp)
  70 +           {
  71 +             nat_addr = cache->saved_regs[IA64_RNAT_REGNUM];
  72 +             if (nat_addr != 0)
  73 +               read_memory (nat_addr, (char *) &nat_collection,
  74 +                            register_size (current_gdbarch, IA64_RNAT_REGNUM));
  75 +           }
  76 +         else
  77 +           nat_collection = read_memory_integer (nat_addr, 8);
  78 +         if (nat_addr != 0)
  79 +           {
  80 +             nat_bit = (gr_addr >> 3) & 0x3f;
  81 +             natN_val = (nat_collection >> nat_bit) & 1;
  82 +             return frame_unwind_got_constant (this_frame, regnum, natN_val);
  83 +           }
  84 +       }
  85 +      warning (_("ia64_sigtramp_frame_prev_register: unhandled register %d"),
  86 +              regnum);
  87 +    }
  88 +  else if (regnum == VBOF_REGNUM)
  89 +    {
  90 +      /* BOF pseudo register.
  91 +       * "copied" from ia64_pseudo_register_read()
  92 +       *
  93 +       * A virtual register frame start is provided for user convenience.
  94 +       * It can be calculated as the bsp - sof (sizeof frame). */
  95 +      ULONGEST bsp;
  96 +      ULONGEST cfm;
  97 +      ULONGEST bof;
  98 +
  99 +      read_memory (cache->saved_regs[IA64_BSP_REGNUM], (char *) &bsp,
 100 +                  register_size (current_gdbarch, IA64_BSP_REGNUM));
 101 +      read_memory (cache->saved_regs[IA64_CFM_REGNUM], (char *) &cfm,
 102 +                  register_size (current_gdbarch, IA64_CFM_REGNUM));
 103 +
 104 +      /* The bsp points at the end of the register frame so we
 105 +        subtract the size of frame from it to get beginning of frame.  */
 106 +      bof = rse_address_add (bsp, -(cfm & 0x7f));
 107 +
 108 +      return frame_unwind_got_constant (this_frame, regnum, bof);
 109 +    }
 110 +  /* Red Hat patch end.  */
 111 +
 112    else if ((regnum >= IA64_GR32_REGNUM && regnum <= IA64_GR127_REGNUM)
 113             || (regnum >= V32_REGNUM && regnum <= V127_REGNUM))
 114      {
 115 @@ -2121,7 +2209,42 @@ ia64_sigtramp_frame_prev_register (struc
 116        return frame_unwind_got_constant (this_frame, regnum, 0);
 117      }
 118
 119 -  else  /* All other registers not listed above.  */
 120 +  /* Red Hat patch begin.  */
 121 +  else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
 122 +    {
 123 +      /* VP 0-63.
 124 +       * "copied" from ia64_pseudo_register_read()
 125 +       *
 126 +       * FIXME: Not currently tested--cannot get the frame to include PR. */
 127 +      CORE_ADDR pr_addr = 0;
 128 +
 129 +      pr_addr = cache->saved_regs[IA64_PR_REGNUM];
 130 +      if (pr_addr != 0)
 131 +       {
 132 +         ULONGEST pr;
 133 +         ULONGEST cfm;
 134 +         ULONGEST prN_val;
 135 +         read_memory (pr_addr, (char *) &pr,
 136 +                      register_size (current_gdbarch, IA64_PR_REGNUM));
 137 +         read_memory (cache->saved_regs[IA64_CFM_REGNUM], (char *) &cfm,
 138 +                      register_size (current_gdbarch, IA64_CFM_REGNUM));
 139 +
 140 +         /* Get the register rename base for this frame and adjust the
 141 +          * register name to take rotation into account. */
 142 +         if (VP16_REGNUM <= regnum && regnum <= VP63_REGNUM)
 143 +           {
 144 +             int rrb_pr = (cfm >> 32) & 0x3f;
 145 +             regnum = VP16_REGNUM + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
 146 +           }
 147 +         prN_val = (pr & (1LL << (regnum - VP0_REGNUM))) != 0;
 148 +         return frame_unwind_got_constant (this_frame, regnum, prN_val);
 149 +       }
 150 +      warning (_("ia64_sigtramp_frame_prev_register: unhandled register %d"),
 151 +              regnum);
 152 +    }
 153 +  /* Red Hat patch end.  */
 154 +
 155 +  /* All other registers not listed above.  */
 156      {
 157        CORE_ADDR addr = cache->saved_regs[regnum];
 158