gdb/mn10300-linux-tdep.c

   1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
   2
   3    Copyright (C) 2003-2015 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdbcore.h"
  22 #include "regcache.h"
  23 #include "mn10300-tdep.h"
  24 #include "bfd.h"
  25 #include "elf-bfd.h"
  26 #include "osabi.h"
  27 #include "regset.h"
  28 #include "solib-svr4.h"
  29 #include "frame.h"
  30 #include "trad-frame.h"
  31 #include "tramp-frame.h"
  32 #include "linux-tdep.h"
  33
  34 /* Transliterated from <asm-mn10300/elf.h>...  */
  35 #define MN10300_ELF_NGREG 28
  36 #define MN10300_ELF_NFPREG 32
  37
  38 typedef gdb_byte   mn10300_elf_greg_t[4];
  39 typedef mn10300_elf_greg_t mn10300_elf_gregset_t[MN10300_ELF_NGREG];
  40
  41 typedef gdb_byte   mn10300_elf_fpreg_t[4];
  42 typedef struct
  43 {
  44   mn10300_elf_fpreg_t fpregs[MN10300_ELF_NFPREG];
  45   gdb_byte    fpcr[4];
  46 } mn10300_elf_fpregset_t;
  47
  48 /* elf_gregset_t register indices stolen from include/asm-mn10300/ptrace.h.  */
  49 #define MN10300_ELF_GREGSET_T_REG_INDEX_A3      0
  50 #define MN10300_ELF_GREGSET_T_REG_INDEX_A2      1
  51 #define MN10300_ELF_GREGSET_T_REG_INDEX_D3      2
  52 #define MN10300_ELF_GREGSET_T_REG_INDEX_D2      3
  53 #define MN10300_ELF_GREGSET_T_REG_INDEX_MCVF    4
  54 #define MN10300_ELF_GREGSET_T_REG_INDEX_MCRL    5
  55 #define MN10300_ELF_GREGSET_T_REG_INDEX_MCRH    6
  56 #define MN10300_ELF_GREGSET_T_REG_INDEX_MDRQ    7
  57 #define MN10300_ELF_GREGSET_T_REG_INDEX_E1      8
  58 #define MN10300_ELF_GREGSET_T_REG_INDEX_E0      9
  59 #define MN10300_ELF_GREGSET_T_REG_INDEX_E7      10
  60 #define MN10300_ELF_GREGSET_T_REG_INDEX_E6      11
  61 #define MN10300_ELF_GREGSET_T_REG_INDEX_E5      12
  62 #define MN10300_ELF_GREGSET_T_REG_INDEX_E4      13
  63 #define MN10300_ELF_GREGSET_T_REG_INDEX_E3      14
  64 #define MN10300_ELF_GREGSET_T_REG_INDEX_E2      15
  65 #define MN10300_ELF_GREGSET_T_REG_INDEX_SP      16
  66 #define MN10300_ELF_GREGSET_T_REG_INDEX_LAR     17
  67 #define MN10300_ELF_GREGSET_T_REG_INDEX_LIR     18
  68 #define MN10300_ELF_GREGSET_T_REG_INDEX_MDR     19
  69 #define MN10300_ELF_GREGSET_T_REG_INDEX_A1      20
  70 #define MN10300_ELF_GREGSET_T_REG_INDEX_A0      21
  71 #define MN10300_ELF_GREGSET_T_REG_INDEX_D1      22
  72 #define MN10300_ELF_GREGSET_T_REG_INDEX_D0      23
  73 #define MN10300_ELF_GREGSET_T_REG_INDEX_ORIG_D0 24
  74 #define MN10300_ELF_GREGSET_T_REG_INDEX_EPSW    25
  75 #define MN10300_ELF_GREGSET_T_REG_INDEX_PC      26
  76
  77 /* New gdbarch API for corefile registers.
  78    Given a section name and size, create a struct reg object
  79    with a supply_register and a collect_register method.  */
  80
  81 /* Copy register value of REGNUM from regset to regcache.
  82    If REGNUM is -1, do this for all gp registers in regset.  */
  83
  84 static void
  85 am33_supply_gregset_method (const struct regset *regset,
  86                             struct regcache *regcache,
  87                             int regnum, const void *gregs, size_t len)
  88 {
  89   char zerobuf[MAX_REGISTER_SIZE];
  90   const mn10300_elf_greg_t *regp = (const mn10300_elf_greg_t *) gregs;
  91   int i;
  92
  93   gdb_assert (len >= sizeof (mn10300_elf_gregset_t));
  94
  95   switch (regnum) {
  96   case E_D0_REGNUM:
  97     regcache_raw_supply (regcache, E_D0_REGNUM,
  98                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D0));
  99     break;
 100   case E_D1_REGNUM:
 101     regcache_raw_supply (regcache, E_D1_REGNUM,
 102                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D1));
 103     break;
 104   case E_D2_REGNUM:
 105     regcache_raw_supply (regcache, E_D2_REGNUM,
 106                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D2));
 107     break;
 108   case E_D3_REGNUM:
 109     regcache_raw_supply (regcache, E_D3_REGNUM,
 110                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D3));
 111     break;
 112   case E_A0_REGNUM:
 113     regcache_raw_supply (regcache, E_A0_REGNUM,
 114                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A0));
 115     break;
 116   case E_A1_REGNUM:
 117     regcache_raw_supply (regcache, E_A1_REGNUM,
 118                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A1));
 119     break;
 120   case E_A2_REGNUM:
 121     regcache_raw_supply (regcache, E_A2_REGNUM,
 122                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A2));
 123     break;
 124   case E_A3_REGNUM:
 125     regcache_raw_supply (regcache, E_A3_REGNUM,
 126                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A3));
 127     break;
 128   case E_SP_REGNUM:
 129     regcache_raw_supply (regcache, E_SP_REGNUM,
 130                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_SP));
 131     break;
 132   case E_PC_REGNUM:
 133     regcache_raw_supply (regcache, E_PC_REGNUM,
 134                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_PC));
 135     break;
 136   case E_MDR_REGNUM:
 137     regcache_raw_supply (regcache, E_MDR_REGNUM,
 138                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MDR));
 139     break;
 140   case E_PSW_REGNUM:
 141     regcache_raw_supply (regcache, E_PSW_REGNUM,
 142                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_EPSW));
 143     break;
 144   case E_LIR_REGNUM:
 145     regcache_raw_supply (regcache, E_LIR_REGNUM,
 146                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_LIR));
 147     break;
 148   case E_LAR_REGNUM:
 149     regcache_raw_supply (regcache, E_LAR_REGNUM,
 150                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_LAR));
 151     break;
 152   case E_MDRQ_REGNUM:
 153     regcache_raw_supply (regcache, E_MDRQ_REGNUM,
 154                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MDRQ));
 155     break;
 156   case E_E0_REGNUM:
 157     regcache_raw_supply (regcache, E_E0_REGNUM,
 158                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E0));
 159     break;
 160   case E_E1_REGNUM:
 161     regcache_raw_supply (regcache, E_E1_REGNUM,
 162                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E1));
 163     break;
 164   case E_E2_REGNUM:
 165     regcache_raw_supply (regcache, E_E2_REGNUM,
 166                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E2));
 167     break;
 168   case E_E3_REGNUM:
 169     regcache_raw_supply (regcache, E_E3_REGNUM,
 170                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E3));
 171     break;
 172   case E_E4_REGNUM:
 173     regcache_raw_supply (regcache, E_E4_REGNUM,
 174                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E4));
 175     break;
 176   case E_E5_REGNUM:
 177     regcache_raw_supply (regcache, E_E5_REGNUM,
 178                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E5));
 179     break;
 180   case E_E6_REGNUM:
 181     regcache_raw_supply (regcache, E_E6_REGNUM,
 182                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E6));
 183     break;
 184   case E_E7_REGNUM:
 185     regcache_raw_supply (regcache, E_E7_REGNUM,
 186                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E7));
 187     break;
 188
 189     /* ssp, msp, and usp are inaccessible.  */
 190   case E_E8_REGNUM:
 191     memset (zerobuf, 0, MAX_REGISTER_SIZE);
 192     regcache_raw_supply (regcache, E_E8_REGNUM, zerobuf);
 193     break;
 194   case E_E9_REGNUM:
 195     memset (zerobuf, 0, MAX_REGISTER_SIZE);
 196     regcache_raw_supply (regcache, E_E9_REGNUM, zerobuf);
 197     break;
 198   case E_E10_REGNUM:
 199     memset (zerobuf, 0, MAX_REGISTER_SIZE);
 200     regcache_raw_supply (regcache, E_E10_REGNUM, zerobuf);
 201
 202     break;
 203   case E_MCRH_REGNUM:
 204     regcache_raw_supply (regcache, E_MCRH_REGNUM,
 205                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCRH));
 206     break;
 207   case E_MCRL_REGNUM:
 208     regcache_raw_supply (regcache, E_MCRL_REGNUM,
 209                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCRL));
 210     break;
 211   case E_MCVF_REGNUM:
 212     regcache_raw_supply (regcache, E_MCVF_REGNUM,
 213                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCVF));
 214     break;
 215   case E_FPCR_REGNUM:
 216     /* FPCR is numbered among the GP regs, but handled as an FP reg.
 217        Do nothing.  */
 218     break;
 219   case E_FPCR_REGNUM + 1:
 220     /* The two unused registers beyond fpcr are inaccessible.  */
 221     memset (zerobuf, 0, MAX_REGISTER_SIZE);
 222     regcache_raw_supply (regcache, E_FPCR_REGNUM + 1, zerobuf);
 223     break;
 224   case E_FPCR_REGNUM + 2:
 225     memset (zerobuf, 0, MAX_REGISTER_SIZE);
 226     regcache_raw_supply (regcache, E_FPCR_REGNUM + 2, zerobuf);
 227     break;
 228   default:      /* An error, obviously, but should we error out?  */
 229     break;
 230   case -1:
 231     for (i = 0; i < MN10300_ELF_NGREG; i++)
 232       am33_supply_gregset_method (regset, regcache, i, gregs, len);
 233     break;
 234   }
 235   return;
 236 }
 237
 238 /* Copy fp register value of REGNUM from regset to regcache.
 239    If REGNUM is -1, do this for all fp registers in regset.  */
 240
 241 static void
 242 am33_supply_fpregset_method (const struct regset *regset,
 243                              struct regcache *regcache,
 244                              int regnum, const void *fpregs, size_t len)
 245 {
 246   const mn10300_elf_fpregset_t *fpregset = fpregs;
 247
 248   gdb_assert (len >= sizeof (mn10300_elf_fpregset_t));
 249
 250   if (regnum == -1)
 251     {
 252       int i;
 253
 254       for (i = 0; i < MN10300_ELF_NFPREG; i++)
 255         am33_supply_fpregset_method (regset, regcache,
 256                                      E_FS0_REGNUM + i, fpregs, len);
 257       am33_supply_fpregset_method (regset, regcache,
 258                                    E_FPCR_REGNUM, fpregs, len);
 259     }
 260   else if (regnum == E_FPCR_REGNUM)
 261     regcache_raw_supply (regcache, E_FPCR_REGNUM,
 262                          &fpregset->fpcr);
 263   else if (E_FS0_REGNUM <= regnum
 264            && regnum < E_FS0_REGNUM + MN10300_ELF_NFPREG)
 265     regcache_raw_supply (regcache, regnum,
 266                          &fpregset->fpregs[regnum - E_FS0_REGNUM]);
 267
 268   return;
 269 }
 270
 271 /* Copy register values from regcache to regset.  */
 272
 273 static void
 274 am33_collect_gregset_method (const struct regset *regset,
 275                              const struct regcache *regcache,
 276                              int regnum, void *gregs, size_t len)
 277 {
 278   mn10300_elf_gregset_t *regp = gregs;
 279   int i;
 280
 281   gdb_assert (len >= sizeof (mn10300_elf_gregset_t));
 282
 283   switch (regnum) {
 284   case E_D0_REGNUM:
 285     regcache_raw_collect (regcache, E_D0_REGNUM,
 286                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D0));
 287     break;
 288   case E_D1_REGNUM:
 289     regcache_raw_collect (regcache, E_D1_REGNUM,
 290                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D1));
 291     break;
 292   case E_D2_REGNUM:
 293     regcache_raw_collect (regcache, E_D2_REGNUM,
 294                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D2));
 295     break;
 296   case E_D3_REGNUM:
 297     regcache_raw_collect (regcache, E_D3_REGNUM,
 298                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D3));
 299     break;
 300   case E_A0_REGNUM:
 301     regcache_raw_collect (regcache, E_A0_REGNUM,
 302                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A0));
 303     break;
 304   case E_A1_REGNUM:
 305     regcache_raw_collect (regcache, E_A1_REGNUM,
 306                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A1));
 307     break;
 308   case E_A2_REGNUM:
 309     regcache_raw_collect (regcache, E_A2_REGNUM,
 310                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A2));
 311     break;
 312   case E_A3_REGNUM:
 313     regcache_raw_collect (regcache, E_A3_REGNUM,
 314                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A3));
 315     break;
 316   case E_SP_REGNUM:
 317     regcache_raw_collect (regcache, E_SP_REGNUM,
 318                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_SP));
 319     break;
 320   case E_PC_REGNUM:
 321     regcache_raw_collect (regcache, E_PC_REGNUM,
 322                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_PC));
 323     break;
 324   case E_MDR_REGNUM:
 325     regcache_raw_collect (regcache, E_MDR_REGNUM,
 326                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MDR));
 327     break;
 328   case E_PSW_REGNUM:
 329     regcache_raw_collect (regcache, E_PSW_REGNUM,
 330                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_EPSW));
 331     break;
 332   case E_LIR_REGNUM:
 333     regcache_raw_collect (regcache, E_LIR_REGNUM,
 334                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_LIR));
 335     break;
 336   case E_LAR_REGNUM:
 337     regcache_raw_collect (regcache, E_LAR_REGNUM,
 338                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_LAR));
 339     break;
 340   case E_MDRQ_REGNUM:
 341     regcache_raw_collect (regcache, E_MDRQ_REGNUM,
 342                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MDRQ));
 343     break;
 344   case E_E0_REGNUM:
 345     regcache_raw_collect (regcache, E_E0_REGNUM,
 346                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E0));
 347     break;
 348   case E_E1_REGNUM:
 349     regcache_raw_collect (regcache, E_E1_REGNUM,
 350                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E1));
 351     break;
 352   case E_E2_REGNUM:
 353     regcache_raw_collect (regcache, E_E2_REGNUM,
 354                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E2));
 355     break;
 356   case E_E3_REGNUM:
 357     regcache_raw_collect (regcache, E_E3_REGNUM,
 358                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E3));
 359     break;
 360   case E_E4_REGNUM:
 361     regcache_raw_collect (regcache, E_E4_REGNUM,
 362                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E4));
 363     break;
 364   case E_E5_REGNUM:
 365     regcache_raw_collect (regcache, E_E5_REGNUM,
 366                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E5));
 367     break;
 368   case E_E6_REGNUM:
 369     regcache_raw_collect (regcache, E_E6_REGNUM,
 370                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E6));
 371     break;
 372   case E_E7_REGNUM:
 373     regcache_raw_collect (regcache, E_E7_REGNUM,
 374                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E7));
 375     break;
 376
 377     /* ssp, msp, and usp are inaccessible.  */
 378   case E_E8_REGNUM:
 379     /* The gregset struct has noplace to put this: do nothing.  */
 380     break;
 381   case E_E9_REGNUM:
 382     /* The gregset struct has noplace to put this: do nothing.  */
 383     break;
 384   case E_E10_REGNUM:
 385     /* The gregset struct has noplace to put this: do nothing.  */
 386     break;
 387   case E_MCRH_REGNUM:
 388     regcache_raw_collect (regcache, E_MCRH_REGNUM,
 389                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCRH));
 390     break;
 391   case E_MCRL_REGNUM:
 392     regcache_raw_collect (regcache, E_MCRL_REGNUM,
 393                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCRL));
 394     break;
 395   case E_MCVF_REGNUM:
 396     regcache_raw_collect (regcache, E_MCVF_REGNUM,
 397                          (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCVF));
 398     break;
 399   case E_FPCR_REGNUM:
 400     /* FPCR is numbered among the GP regs, but handled as an FP reg.
 401        Do nothing.  */
 402     break;
 403   case E_FPCR_REGNUM + 1:
 404     /* The gregset struct has noplace to put this: do nothing.  */
 405     break;
 406   case E_FPCR_REGNUM + 2:
 407     /* The gregset struct has noplace to put this: do nothing.  */
 408     break;
 409   default:      /* An error, obviously, but should we error out?  */
 410     break;
 411   case -1:
 412     for (i = 0; i < MN10300_ELF_NGREG; i++)
 413       am33_collect_gregset_method (regset, regcache, i, gregs, len);
 414     break;
 415   }
 416   return;
 417 }
 418
 419 /* Copy fp register values from regcache to regset.  */
 420
 421 static void
 422 am33_collect_fpregset_method (const struct regset *regset,
 423                               const struct regcache *regcache,
 424                               int regnum, void *fpregs, size_t len)
 425 {
 426   mn10300_elf_fpregset_t *fpregset = fpregs;
 427
 428   gdb_assert (len >= sizeof (mn10300_elf_fpregset_t));
 429
 430   if (regnum == -1)
 431     {
 432       int i;
 433       for (i = 0; i < MN10300_ELF_NFPREG; i++)
 434         am33_collect_fpregset_method (regset, regcache, E_FS0_REGNUM + i,
 435                                       fpregs, len);
 436       am33_collect_fpregset_method (regset, regcache,
 437                                     E_FPCR_REGNUM, fpregs, len);
 438     }
 439   else if (regnum == E_FPCR_REGNUM)
 440     regcache_raw_collect (regcache, E_FPCR_REGNUM,
 441                           &fpregset->fpcr);
 442   else if (E_FS0_REGNUM <= regnum
 443            && regnum < E_FS0_REGNUM + MN10300_ELF_NFPREG)
 444     regcache_raw_collect (regcache, regnum,
 445                           &fpregset->fpregs[regnum - E_FS0_REGNUM]);
 446
 447   return;
 448 }
 449
 450 static const struct regset am33_gregset =
 451   {
 452     NULL, am33_supply_gregset_method, am33_collect_gregset_method
 453   };
 454
 455 static const struct regset am33_fpregset =
 456   {
 457     NULL, am33_supply_fpregset_method, am33_collect_fpregset_method
 458   };
 459
 460 /* Iterate over core file register note sections.  */
 461
 462 static void
 463 am33_iterate_over_regset_sections (struct gdbarch *gdbarch,
 464                                    iterate_over_regset_sections_cb *cb,
 465                                    void *cb_data,
 466                                    const struct regcache *regcache)
 467 {
 468   cb (".reg", sizeof (mn10300_elf_gregset_t), &am33_gregset,
 469       NULL, cb_data);
 470   cb (".reg2", sizeof(mn10300_elf_fpregset_t), &am33_fpregset,
 471       NULL, cb_data);
 472 }
 473 \f
 474 static void
 475 am33_linux_sigframe_cache_init (const struct tramp_frame *self,
 476                                 struct frame_info *this_frame,
 477                                 struct trad_frame_cache *this_cache,
 478                                 CORE_ADDR func);
 479
 480 static const struct tramp_frame am33_linux_sigframe = {
 481   SIGTRAMP_FRAME,
 482   1,
 483   {
 484     /* mov     119,d0 */
 485     { 0x2c, -1 },
 486     { 0x77, -1 },
 487     { 0x00, -1 },
 488     /* syscall 0 */
 489     { 0xf0, -1 },
 490     { 0xe0, -1 },
 491     { TRAMP_SENTINEL_INSN, -1 }
 492   },
 493   am33_linux_sigframe_cache_init
 494 };
 495
 496 static const struct tramp_frame am33_linux_rt_sigframe = {
 497   SIGTRAMP_FRAME,
 498   1,
 499   {
 500     /* mov     173,d0 */
 501     { 0x2c, -1 },
 502     { 0xad, -1 },
 503     { 0x00, -1 },
 504     /* syscall 0 */
 505     { 0xf0, -1 },
 506     { 0xe0, -1 },
 507     { TRAMP_SENTINEL_INSN, -1 }
 508   },
 509   am33_linux_sigframe_cache_init
 510 };
 511
 512 /* Relevant struct definitions for signal handling...
 513
 514 From arch/mn10300/kernel/sigframe.h:
 515
 516 struct sigframe
 517 {
 518         void (*pretcode)(void);
 519         int sig;
 520         struct sigcontext *psc;
 521         struct sigcontext sc;
 522         struct fpucontext fpuctx;
 523         unsigned long extramask[_NSIG_WORDS-1];
 524         char retcode[8];
 525 };
 526
 527 struct rt_sigframe
 528 {
 529         void (*pretcode)(void);
 530         int sig;
 531         struct siginfo *pinfo;
 532         void *puc;
 533         struct siginfo info;
 534         struct ucontext uc;
 535         struct fpucontext fpuctx;
 536         char retcode[8];
 537 };
 538
 539 From include/asm-mn10300/ucontext.h:
 540
 541 struct ucontext {
 542         unsigned long     uc_flags;
 543         struct ucontext  *uc_link;
 544         stack_t           uc_stack;
 545         struct sigcontext uc_mcontext;
 546         sigset_t          uc_sigmask;
 547 };
 548
 549 From include/asm-mn10300/sigcontext.h:
 550
 551 struct fpucontext {
 552         unsigned long   fs[32];
 553         unsigned long   fpcr;
 554 };
 555
 556 struct sigcontext {
 557         unsigned long   d0;
 558         unsigned long   d1;
 559         unsigned long   d2;
 560         unsigned long   d3;
 561         unsigned long   a0;
 562         unsigned long   a1;
 563         unsigned long   a2;
 564         unsigned long   a3;
 565         unsigned long   e0;
 566         unsigned long   e1;
 567         unsigned long   e2;
 568         unsigned long   e3;
 569         unsigned long   e4;
 570         unsigned long   e5;
 571         unsigned long   e6;
 572         unsigned long   e7;
 573         unsigned long   lar;
 574         unsigned long   lir;
 575         unsigned long   mdr;
 576         unsigned long   mcvf;
 577         unsigned long   mcrl;
 578         unsigned long   mcrh;
 579         unsigned long   mdrq;
 580         unsigned long   sp;
 581         unsigned long   epsw;
 582         unsigned long   pc;
 583         struct fpucontext *fpucontext;
 584         unsigned long   oldmask;
 585 }; */
 586
 587
 588 #define AM33_SIGCONTEXT_D0 0
 589 #define AM33_SIGCONTEXT_D1 4
 590 #define AM33_SIGCONTEXT_D2 8
 591 #define AM33_SIGCONTEXT_D3 12
 592 #define AM33_SIGCONTEXT_A0 16
 593 #define AM33_SIGCONTEXT_A1 20
 594 #define AM33_SIGCONTEXT_A2 24
 595 #define AM33_SIGCONTEXT_A3 28
 596 #define AM33_SIGCONTEXT_E0 32
 597 #define AM33_SIGCONTEXT_E1 36
 598 #define AM33_SIGCONTEXT_E2 40
 599 #define AM33_SIGCONTEXT_E3 44
 600 #define AM33_SIGCONTEXT_E4 48
 601 #define AM33_SIGCONTEXT_E5 52
 602 #define AM33_SIGCONTEXT_E6 56
 603 #define AM33_SIGCONTEXT_E7 60
 604 #define AM33_SIGCONTEXT_LAR 64
 605 #define AM33_SIGCONTEXT_LIR 68
 606 #define AM33_SIGCONTEXT_MDR 72
 607 #define AM33_SIGCONTEXT_MCVF 76
 608 #define AM33_SIGCONTEXT_MCRL 80
 609 #define AM33_SIGCONTEXT_MCRH 84
 610 #define AM33_SIGCONTEXT_MDRQ 88
 611 #define AM33_SIGCONTEXT_SP 92
 612 #define AM33_SIGCONTEXT_EPSW 96
 613 #define AM33_SIGCONTEXT_PC 100
 614 #define AM33_SIGCONTEXT_FPUCONTEXT 104
 615
 616
 617 static void
 618 am33_linux_sigframe_cache_init (const struct tramp_frame *self,
 619                                 struct frame_info *this_frame,
 620                                 struct trad_frame_cache *this_cache,
 621                                 CORE_ADDR func)
 622 {
 623   CORE_ADDR sc_base, fpubase;
 624   int i;
 625
 626   sc_base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 627   if (self == &am33_linux_sigframe)
 628     {
 629       sc_base += 8;
 630       sc_base = get_frame_memory_unsigned (this_frame, sc_base, 4);
 631     }
 632   else
 633     {
 634       sc_base += 12;
 635       sc_base = get_frame_memory_unsigned (this_frame, sc_base, 4);
 636       sc_base += 20;
 637     }
 638
 639   trad_frame_set_reg_addr (this_cache, E_D0_REGNUM,
 640                            sc_base + AM33_SIGCONTEXT_D0);
 641   trad_frame_set_reg_addr (this_cache, E_D1_REGNUM,
 642                            sc_base + AM33_SIGCONTEXT_D1);
 643   trad_frame_set_reg_addr (this_cache, E_D2_REGNUM,
 644                            sc_base + AM33_SIGCONTEXT_D2);
 645   trad_frame_set_reg_addr (this_cache, E_D3_REGNUM,
 646                            sc_base + AM33_SIGCONTEXT_D3);
 647
 648   trad_frame_set_reg_addr (this_cache, E_A0_REGNUM,
 649                            sc_base + AM33_SIGCONTEXT_A0);
 650   trad_frame_set_reg_addr (this_cache, E_A1_REGNUM,
 651                            sc_base + AM33_SIGCONTEXT_A1);
 652   trad_frame_set_reg_addr (this_cache, E_A2_REGNUM,
 653                            sc_base + AM33_SIGCONTEXT_A2);
 654   trad_frame_set_reg_addr (this_cache, E_A3_REGNUM,
 655                            sc_base + AM33_SIGCONTEXT_A3);
 656
 657   trad_frame_set_reg_addr (this_cache, E_E0_REGNUM,
 658                            sc_base + AM33_SIGCONTEXT_E0);
 659   trad_frame_set_reg_addr (this_cache, E_E1_REGNUM,
 660                            sc_base + AM33_SIGCONTEXT_E1);
 661   trad_frame_set_reg_addr (this_cache, E_E2_REGNUM,
 662                            sc_base + AM33_SIGCONTEXT_E2);
 663   trad_frame_set_reg_addr (this_cache, E_E3_REGNUM,
 664                            sc_base + AM33_SIGCONTEXT_E3);
 665   trad_frame_set_reg_addr (this_cache, E_E4_REGNUM,
 666                            sc_base + AM33_SIGCONTEXT_E4);
 667   trad_frame_set_reg_addr (this_cache, E_E5_REGNUM,
 668                            sc_base + AM33_SIGCONTEXT_E5);
 669   trad_frame_set_reg_addr (this_cache, E_E6_REGNUM,
 670                            sc_base + AM33_SIGCONTEXT_E6);
 671   trad_frame_set_reg_addr (this_cache, E_E7_REGNUM,
 672                            sc_base + AM33_SIGCONTEXT_E7);
 673
 674   trad_frame_set_reg_addr (this_cache, E_LAR_REGNUM,
 675                            sc_base + AM33_SIGCONTEXT_LAR);
 676   trad_frame_set_reg_addr (this_cache, E_LIR_REGNUM,
 677                            sc_base + AM33_SIGCONTEXT_LIR);
 678   trad_frame_set_reg_addr (this_cache, E_MDR_REGNUM,
 679                            sc_base + AM33_SIGCONTEXT_MDR);
 680   trad_frame_set_reg_addr (this_cache, E_MCVF_REGNUM,
 681                            sc_base + AM33_SIGCONTEXT_MCVF);
 682   trad_frame_set_reg_addr (this_cache, E_MCRL_REGNUM,
 683                            sc_base + AM33_SIGCONTEXT_MCRL);
 684   trad_frame_set_reg_addr (this_cache, E_MDRQ_REGNUM,
 685                            sc_base + AM33_SIGCONTEXT_MDRQ);
 686
 687   trad_frame_set_reg_addr (this_cache, E_SP_REGNUM,
 688                            sc_base + AM33_SIGCONTEXT_SP);
 689   trad_frame_set_reg_addr (this_cache, E_PSW_REGNUM,
 690                            sc_base + AM33_SIGCONTEXT_EPSW);
 691   trad_frame_set_reg_addr (this_cache, E_PC_REGNUM,
 692                            sc_base + AM33_SIGCONTEXT_PC);
 693
 694   fpubase = get_frame_memory_unsigned (this_frame,
 695                                        sc_base + AM33_SIGCONTEXT_FPUCONTEXT,
 696                                        4);
 697   if (fpubase)
 698     {
 699       for (i = 0; i < 32; i++)
 700         {
 701           trad_frame_set_reg_addr (this_cache, E_FS0_REGNUM + i,
 702                                    fpubase + 4 * i);
 703         }
 704       trad_frame_set_reg_addr (this_cache, E_FPCR_REGNUM, fpubase + 4 * 32);
 705     }
 706
 707   trad_frame_set_id (this_cache, frame_id_build (sc_base, func));
 708 }
 709 \f
 710 /* AM33 GNU/Linux osabi has been recognized.
 711    Now's our chance to register our corefile handling.  */
 712
 713 static void
 714 am33_linux_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
 715 {
 716   linux_init_abi (info, gdbarch);
 717
 718   set_gdbarch_iterate_over_regset_sections
 719     (gdbarch, am33_iterate_over_regset_sections);
 720   set_solib_svr4_fetch_link_map_offsets
 721     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 722
 723   tramp_frame_prepend_unwinder (gdbarch, &am33_linux_sigframe);
 724   tramp_frame_prepend_unwinder (gdbarch, &am33_linux_rt_sigframe);
 725 }
 726
 727 /* Provide a prototype to silence -Wmissing-prototypes.  */
 728 extern initialize_file_ftype _initialize_mn10300_linux_tdep;
 729
 730 void
 731 _initialize_mn10300_linux_tdep (void)
 732 {
 733   gdbarch_register_osabi (bfd_arch_mn10300, 0,
 734                           GDB_OSABI_LINUX, am33_linux_init_osabi);
 735 }
 736