gdb/mep-tdep.c

   1 /* Target-dependent code for the Toshiba MeP for GDB, the GNU debugger.
   2
   3    Copyright (C) 2001-2017 Free Software Foundation, Inc.
   4
   5    Contributed by Red Hat, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "frame-unwind.h"
  25 #include "frame-base.h"
  26 #include "symtab.h"
  27 #include "gdbtypes.h"
  28 #include "gdbcmd.h"
  29 #include "gdbcore.h"
  30 #include "value.h"
  31 #include "inferior.h"
  32 #include "dis-asm.h"
  33 #include "symfile.h"
  34 #include "objfiles.h"
  35 #include "language.h"
  36 #include "arch-utils.h"
  37 #include "regcache.h"
  38 #include "remote.h"
  39 #include "sim-regno.h"
  40 #include "disasm.h"
  41 #include "trad-frame.h"
  42 #include "reggroups.h"
  43 #include "elf-bfd.h"
  44 #include "elf/mep.h"
  45 #include "prologue-value.h"
  46 #include "cgen/bitset.h"
  47 #include "infcall.h"
  48
  49 /* Get the user's customized MeP coprocessor register names from
  50    libopcodes.  */
  51 #include "opcodes/mep-desc.h"
  52 #include "opcodes/mep-opc.h"
  53
  54 \f
  55 /* The gdbarch_tdep structure.  */
  56
  57 /* A quick recap for GDB hackers not familiar with the whole Toshiba
  58    Media Processor story:
  59
  60    The MeP media engine is a configureable processor: users can design
  61    their own coprocessors, implement custom instructions, adjust cache
  62    sizes, select optional standard facilities like add-and-saturate
  63    instructions, and so on.  Then, they can build custom versions of
  64    the GNU toolchain to support their customized chips.  The
  65    MeP-Integrator program (see utils/mep) takes a GNU toolchain source
  66    tree, and a config file pointing to various files provided by the
  67    user describing their customizations, and edits the source tree to
  68    produce a compiler that can generate their custom instructions, an
  69    assembler that can assemble them and recognize their custom
  70    register names, and so on.
  71
  72    Furthermore, the user can actually specify several of these custom
  73    configurations, called 'me_modules', and get a toolchain which can
  74    produce code for any of them, given a compiler/assembler switch;
  75    you say something like 'gcc -mconfig=mm_max' to generate code for
  76    the me_module named 'mm_max'.
  77
  78    GDB, in particular, needs to:
  79
  80    - use the coprocessor control register names provided by the user
  81      in their hardware description, in expressions, 'info register'
  82      output, and disassembly,
  83
  84    - know the number, names, and types of the coprocessor's
  85      general-purpose registers, adjust the 'info all-registers' output
  86      accordingly, and print error messages if the user refers to one
  87      that doesn't exist
  88
  89    - allow access to the control bus space only when the configuration
  90      actually has a control bus, and recognize which regions of the
  91      control bus space are actually populated,
  92
  93    - disassemble using the user's provided mnemonics for their custom
  94      instructions, and
  95
  96    - recognize whether the $hi and $lo registers are present, and
  97      allow access to them only when they are actually there.
  98
  99    There are three sources of information about what sort of me_module
 100    we're actually dealing with:
 101
 102    - A MeP executable file indicates which me_module it was compiled
 103      for, and libopcodes has tables describing each module.  So, given
 104      an executable file, we can find out about the processor it was
 105      compiled for.
 106
 107    - There are SID command-line options to select a particular
 108      me_module, overriding the one specified in the ELF file.  SID
 109      provides GDB with a fake read-only register, 'module', which
 110      indicates which me_module GDB is communicating with an instance
 111      of.
 112
 113    - There are SID command-line options to enable or disable certain
 114      optional processor features, overriding the defaults for the
 115      selected me_module.  The MeP $OPT register indicates which
 116      options are present on the current processor.  */
 117
 118
 119 struct gdbarch_tdep
 120 {
 121   /* A CGEN cpu descriptor for this BFD architecture and machine.
 122
 123      Note: this is *not* customized for any particular me_module; the
 124      MeP libopcodes machinery actually puts off module-specific
 125      customization until the last minute.  So this contains
 126      information about all supported me_modules.  */
 127   CGEN_CPU_DESC cpu_desc;
 128
 129   /* The me_module index from the ELF file we used to select this
 130      architecture, or CONFIG_NONE if there was none.
 131
 132      Note that we should prefer to use the me_module number available
 133      via the 'module' register, whenever we're actually talking to a
 134      real target.
 135
 136      In the absence of live information, we'd like to get the
 137      me_module number from the ELF file.  But which ELF file: the
 138      executable file, the core file, ... ?  The answer is, "the last
 139      ELF file we used to set the current architecture".  Thus, we
 140      create a separate instance of the gdbarch structure for each
 141      me_module value mep_gdbarch_init sees, and store the me_module
 142      value from the ELF file here.  */
 143   CONFIG_ATTR me_module;
 144 };
 145
 146
 147 \f
 148 /* Getting me_module information from the CGEN tables.  */
 149
 150
 151 /* Find an entry in the DESC's hardware table whose name begins with
 152    PREFIX, and whose ISA mask intersects COPRO_ISA_MASK, but does not
 153    intersect with GENERIC_ISA_MASK.  If there is no matching entry,
 154    return zero.  */
 155 static const CGEN_HW_ENTRY *
 156 find_hw_entry_by_prefix_and_isa (CGEN_CPU_DESC desc,
 157                                  const char *prefix,
 158                                  CGEN_BITSET *copro_isa_mask,
 159                                  CGEN_BITSET *generic_isa_mask)
 160 {
 161   int prefix_len = strlen (prefix);
 162   int i;
 163
 164   for (i = 0; i < desc->hw_table.num_entries; i++)
 165     {
 166       const CGEN_HW_ENTRY *hw = desc->hw_table.entries[i];
 167       if (strncmp (prefix, hw->name, prefix_len) == 0)
 168         {
 169           CGEN_BITSET *hw_isa_mask
 170             = ((CGEN_BITSET *)
 171                &CGEN_ATTR_CGEN_HW_ISA_VALUE (CGEN_HW_ATTRS (hw)));
 172
 173           if (cgen_bitset_intersect_p (hw_isa_mask, copro_isa_mask)
 174               && ! cgen_bitset_intersect_p (hw_isa_mask, generic_isa_mask))
 175             return hw;
 176         }
 177     }
 178
 179   return 0;
 180 }
 181
 182
 183 /* Find an entry in DESC's hardware table whose type is TYPE.  Return
 184    zero if there is none.  */
 185 static const CGEN_HW_ENTRY *
 186 find_hw_entry_by_type (CGEN_CPU_DESC desc, CGEN_HW_TYPE type)
 187 {
 188   int i;
 189
 190   for (i = 0; i < desc->hw_table.num_entries; i++)
 191     {
 192       const CGEN_HW_ENTRY *hw = desc->hw_table.entries[i];
 193
 194       if (hw->type == type)
 195         return hw;
 196     }
 197
 198   return 0;
 199 }
 200
 201
 202 /* Return the CGEN hardware table entry for the coprocessor register
 203    set for ME_MODULE, whose name prefix is PREFIX.  If ME_MODULE has
 204    no such register set, return zero.  If ME_MODULE is the generic
 205    me_module CONFIG_NONE, return the table entry for the register set
 206    whose hardware type is GENERIC_TYPE.  */
 207 static const CGEN_HW_ENTRY *
 208 me_module_register_set (CONFIG_ATTR me_module,
 209                         const char *prefix,
 210                         CGEN_HW_TYPE generic_type)
 211 {
 212   /* This is kind of tricky, because the hardware table is constructed
 213      in a way that isn't very helpful.  Perhaps we can fix that, but
 214      here's how it works at the moment:
 215
 216      The configuration map, `mep_config_map', is indexed by me_module
 217      number, and indicates which coprocessor and core ISAs that
 218      me_module supports.  The 'core_isa' mask includes all the core
 219      ISAs, and the 'cop_isa' mask includes all the coprocessor ISAs.
 220      The entry for the generic me_module, CONFIG_NONE, has an empty
 221      'cop_isa', and its 'core_isa' selects only the standard MeP
 222      instruction set.
 223
 224      The CGEN CPU descriptor's hardware table, desc->hw_table, has
 225      entries for all the register sets, for all me_modules.  Each
 226      entry has a mask indicating which ISAs use that register set.
 227      So, if an me_module supports some coprocessor ISA, we can find
 228      applicable register sets by scanning the hardware table for
 229      register sets whose masks include (at least some of) those ISAs.
 230
 231      Each hardware table entry also has a name, whose prefix says
 232      whether it's a general-purpose ("h-cr") or control ("h-ccr")
 233      coprocessor register set.  It might be nicer to have an attribute
 234      indicating what sort of register set it was, that we could use
 235      instead of pattern-matching on the name.
 236
 237      When there is no hardware table entry whose mask includes a
 238      particular coprocessor ISA and whose name starts with a given
 239      prefix, then that means that that coprocessor doesn't have any
 240      registers of that type.  In such cases, this function must return
 241      a null pointer.
 242
 243      Coprocessor register sets' masks may or may not include the core
 244      ISA for the me_module they belong to.  Those generated by a2cgen
 245      do, but the sample me_module included in the unconfigured tree,
 246      'ccfx', does not.
 247
 248      There are generic coprocessor register sets, intended only for
 249      use with the generic me_module.  Unfortunately, their masks
 250      include *all* ISAs --- even those for coprocessors that don't
 251      have such register sets.  This makes detecting the case where a
 252      coprocessor lacks a particular register set more complicated.
 253
 254      So, here's the approach we take:
 255
 256      - For CONFIG_NONE, we return the generic coprocessor register set.
 257
 258      - For any other me_module, we search for a register set whose
 259        mask contains any of the me_module's coprocessor ISAs,
 260        specifically excluding the generic coprocessor register sets.  */
 261
 262   CGEN_CPU_DESC desc = gdbarch_tdep (target_gdbarch ())->cpu_desc;
 263   const CGEN_HW_ENTRY *hw;
 264
 265   if (me_module == CONFIG_NONE)
 266     hw = find_hw_entry_by_type (desc, generic_type);
 267   else
 268     {
 269       CGEN_BITSET *cop = &mep_config_map[me_module].cop_isa;
 270       CGEN_BITSET *core = &mep_config_map[me_module].core_isa;
 271       CGEN_BITSET *generic = &mep_config_map[CONFIG_NONE].core_isa;
 272       CGEN_BITSET *cop_and_core;
 273
 274       /* The coprocessor ISAs include the ISA for the specific core which
 275          has that coprocessor.  */
 276       cop_and_core = cgen_bitset_copy (cop);
 277       cgen_bitset_union (cop, core, cop_and_core);
 278       hw = find_hw_entry_by_prefix_and_isa (desc, prefix, cop_and_core, generic);
 279     }
 280
 281   return hw;
 282 }
 283
 284
 285 /* Given a hardware table entry HW representing a register set, return
 286    a pointer to the keyword table with all the register names.  If HW
 287    is NULL, return NULL, to propage the "no such register set" info
 288    along.  */
 289 static CGEN_KEYWORD *
 290 register_set_keyword_table (const CGEN_HW_ENTRY *hw)
 291 {
 292   if (! hw)
 293     return NULL;
 294
 295   /* Check that HW is actually a keyword table.  */
 296   gdb_assert (hw->asm_type == CGEN_ASM_KEYWORD);
 297
 298   /* The 'asm_data' field of a register set's hardware table entry
 299      refers to a keyword table.  */
 300   return (CGEN_KEYWORD *) hw->asm_data;
 301 }
 302
 303
 304 /* Given a keyword table KEYWORD and a register number REGNUM, return
 305    the name of the register, or "" if KEYWORD contains no register
 306    whose number is REGNUM.  */
 307 static const char *
 308 register_name_from_keyword (CGEN_KEYWORD *keyword_table, int regnum)
 309 {
 310   const CGEN_KEYWORD_ENTRY *entry
 311     = cgen_keyword_lookup_value (keyword_table, regnum);
 312
 313   if (entry)
 314     {
 315       char *name = entry->name;
 316
 317       /* The CGEN keyword entries for register names include the
 318          leading $, which appears in MeP assembly as well as in GDB.
 319          But we don't want to return that; GDB core code adds that
 320          itself.  */
 321       if (name[0] == '$')
 322         name++;
 323
 324       return name;
 325     }
 326   else
 327     return "";
 328 }
 329
 330
 331 /* Masks for option bits in the OPT special-purpose register.  */
 332 enum {
 333   MEP_OPT_DIV = 1 << 25,        /* 32-bit divide instruction option */
 334   MEP_OPT_MUL = 1 << 24,        /* 32-bit multiply instruction option */
 335   MEP_OPT_BIT = 1 << 23,        /* bit manipulation instruction option */
 336   MEP_OPT_SAT = 1 << 22,        /* saturation instruction option */
 337   MEP_OPT_CLP = 1 << 21,        /* clip instruction option */
 338   MEP_OPT_MIN = 1 << 20,        /* min/max instruction option */
 339   MEP_OPT_AVE = 1 << 19,        /* average instruction option */
 340   MEP_OPT_ABS = 1 << 18,        /* absolute difference instruction option */
 341   MEP_OPT_LDZ = 1 << 16,        /* leading zero instruction option */
 342   MEP_OPT_VL64 = 1 << 6,        /* 64-bit VLIW operation mode option */
 343   MEP_OPT_VL32 = 1 << 5,        /* 32-bit VLIW operation mode option */
 344   MEP_OPT_COP = 1 << 4,         /* coprocessor option */
 345   MEP_OPT_DSP = 1 << 2,         /* DSP option */
 346   MEP_OPT_UCI = 1 << 1,         /* UCI option */
 347   MEP_OPT_DBG = 1 << 0,         /* DBG function option */
 348 };
 349
 350
 351 /* Given the option_mask value for a particular entry in
 352    mep_config_map, produce the value the processor's OPT register
 353    would use to represent the same set of options.  */
 354 static unsigned int
 355 opt_from_option_mask (unsigned int option_mask)
 356 {
 357   /* A table mapping OPT register bits onto CGEN config map option
 358      bits.  */
 359   struct {
 360     unsigned int opt_bit, option_mask_bit;
 361   } bits[] = {
 362     { MEP_OPT_DIV, 1 << CGEN_INSN_OPTIONAL_DIV_INSN },
 363     { MEP_OPT_MUL, 1 << CGEN_INSN_OPTIONAL_MUL_INSN },
 364     { MEP_OPT_DIV, 1 << CGEN_INSN_OPTIONAL_DIV_INSN },
 365     { MEP_OPT_DBG, 1 << CGEN_INSN_OPTIONAL_DEBUG_INSN },
 366     { MEP_OPT_LDZ, 1 << CGEN_INSN_OPTIONAL_LDZ_INSN },
 367     { MEP_OPT_ABS, 1 << CGEN_INSN_OPTIONAL_ABS_INSN },
 368     { MEP_OPT_AVE, 1 << CGEN_INSN_OPTIONAL_AVE_INSN },
 369     { MEP_OPT_MIN, 1 << CGEN_INSN_OPTIONAL_MINMAX_INSN },
 370     { MEP_OPT_CLP, 1 << CGEN_INSN_OPTIONAL_CLIP_INSN },
 371     { MEP_OPT_SAT, 1 << CGEN_INSN_OPTIONAL_SAT_INSN },
 372     { MEP_OPT_UCI, 1 << CGEN_INSN_OPTIONAL_UCI_INSN },
 373     { MEP_OPT_DSP, 1 << CGEN_INSN_OPTIONAL_DSP_INSN },
 374     { MEP_OPT_COP, 1 << CGEN_INSN_OPTIONAL_CP_INSN },
 375   };
 376
 377   int i;
 378   unsigned int opt = 0;
 379
 380   for (i = 0; i < (sizeof (bits) / sizeof (bits[0])); i++)
 381     if (option_mask & bits[i].option_mask_bit)
 382       opt |= bits[i].opt_bit;
 383
 384   return opt;
 385 }
 386
 387
 388 /* Return the value the $OPT register would use to represent the set
 389    of options for ME_MODULE.  */
 390 static unsigned int
 391 me_module_opt (CONFIG_ATTR me_module)
 392 {
 393   return opt_from_option_mask (mep_config_map[me_module].option_mask);
 394 }
 395
 396
 397 /* Return the width of ME_MODULE's coprocessor data bus, in bits.
 398    This is either 32 or 64.  */
 399 static int
 400 me_module_cop_data_bus_width (CONFIG_ATTR me_module)
 401 {
 402   if (mep_config_map[me_module].option_mask
 403       & (1 << CGEN_INSN_OPTIONAL_CP64_INSN))
 404     return 64;
 405   else
 406     return 32;
 407 }
 408
 409
 410 /* Return true if ME_MODULE is big-endian, false otherwise.  */
 411 static int
 412 me_module_big_endian (CONFIG_ATTR me_module)
 413 {
 414   return mep_config_map[me_module].big_endian;
 415 }
 416
 417
 418 /* Return the name of ME_MODULE, or NULL if it has no name.  */
 419 static const char *
 420 me_module_name (CONFIG_ATTR me_module)
 421 {
 422   /* The default me_module has "" as its name, but it's easier for our
 423      callers to test for NULL.  */
 424   if (! mep_config_map[me_module].name
 425       || mep_config_map[me_module].name[0] == '\0')
 426     return NULL;
 427   else
 428     return mep_config_map[me_module].name;
 429 }
 430 \f
 431 /* Register set.  */
 432
 433
 434 /* The MeP spec defines the following registers:
 435    16 general purpose registers (r0-r15)
 436    32 control/special registers (csr0-csr31)
 437    32 coprocessor general-purpose registers (c0 -- c31)
 438    64 coprocessor control registers (ccr0 -- ccr63)
 439
 440    For the raw registers, we assign numbers here explicitly, instead
 441    of letting the enum assign them for us; the numbers are a matter of
 442    external protocol, and shouldn't shift around as things are edited.
 443
 444    We access the control/special registers via pseudoregisters, to
 445    enforce read-only portions that some registers have.
 446
 447    We access the coprocessor general purpose and control registers via
 448    pseudoregisters, to make sure they appear in the proper order in
 449    the 'info all-registers' command (which uses the register number
 450    ordering), and also to allow them to be renamed and resized
 451    depending on the me_module in use.
 452
 453    The MeP allows coprocessor general-purpose registers to be either
 454    32 or 64 bits long, depending on the configuration.  Since we don't
 455    want the format of the 'g' packet to vary from one core to another,
 456    the raw coprocessor GPRs are always 64 bits.  GDB doesn't allow the
 457    types of registers to change (see the implementation of
 458    register_type), so we have four banks of pseudoregisters for the
 459    coprocessor gprs --- 32-bit vs. 64-bit, and integer
 460    vs. floating-point --- and we show or hide them depending on the
 461    configuration.  */
 462 enum
 463 {
 464   MEP_FIRST_RAW_REGNUM = 0,
 465
 466   MEP_FIRST_GPR_REGNUM = 0,
 467   MEP_R0_REGNUM = 0,
 468   MEP_R1_REGNUM = 1,
 469   MEP_R2_REGNUM = 2,
 470   MEP_R3_REGNUM = 3,
 471   MEP_R4_REGNUM = 4,
 472   MEP_R5_REGNUM = 5,
 473   MEP_R6_REGNUM = 6,
 474   MEP_R7_REGNUM = 7,
 475   MEP_R8_REGNUM = 8,
 476   MEP_R9_REGNUM = 9,
 477   MEP_R10_REGNUM = 10,
 478   MEP_R11_REGNUM = 11,
 479   MEP_R12_REGNUM = 12,
 480   MEP_FP_REGNUM = MEP_R8_REGNUM,
 481   MEP_R13_REGNUM = 13,
 482   MEP_TP_REGNUM = MEP_R13_REGNUM,       /* (r13) Tiny data pointer */
 483   MEP_R14_REGNUM = 14,
 484   MEP_GP_REGNUM = MEP_R14_REGNUM,       /* (r14) Global pointer */
 485   MEP_R15_REGNUM = 15,
 486   MEP_SP_REGNUM = MEP_R15_REGNUM,       /* (r15) Stack pointer */
 487   MEP_LAST_GPR_REGNUM = MEP_R15_REGNUM,
 488
 489   /* The raw control registers.  These are the values as received via
 490      the remote protocol, directly from the target; we only let user
 491      code touch the via the pseudoregisters, which enforce read-only
 492      bits.  */
 493   MEP_FIRST_RAW_CSR_REGNUM = 16,
 494   MEP_RAW_PC_REGNUM    = 16,    /* Program counter */
 495   MEP_RAW_LP_REGNUM    = 17,    /* Link pointer */
 496   MEP_RAW_SAR_REGNUM   = 18,    /* Raw shift amount */
 497   MEP_RAW_CSR3_REGNUM  = 19,    /* csr3: reserved */
 498   MEP_RAW_RPB_REGNUM   = 20,    /* Raw repeat begin address */
 499   MEP_RAW_RPE_REGNUM   = 21,    /* Repeat end address */
 500   MEP_RAW_RPC_REGNUM   = 22,    /* Repeat count */
 501   MEP_RAW_HI_REGNUM    = 23, /* Upper 32 bits of result of 64 bit mult/div */
 502   MEP_RAW_LO_REGNUM    = 24, /* Lower 32 bits of result of 64 bit mult/div */
 503   MEP_RAW_CSR9_REGNUM  = 25,    /* csr3: reserved */
 504   MEP_RAW_CSR10_REGNUM = 26,    /* csr3: reserved */
 505   MEP_RAW_CSR11_REGNUM = 27,    /* csr3: reserved */
 506   MEP_RAW_MB0_REGNUM   = 28,    /* Raw modulo begin address 0 */
 507   MEP_RAW_ME0_REGNUM   = 29,    /* Raw modulo end address 0 */
 508   MEP_RAW_MB1_REGNUM   = 30,    /* Raw modulo begin address 1 */
 509   MEP_RAW_ME1_REGNUM   = 31,    /* Raw modulo end address 1 */
 510   MEP_RAW_PSW_REGNUM   = 32,    /* Raw program status word */
 511   MEP_RAW_ID_REGNUM    = 33,    /* Raw processor ID/revision */
 512   MEP_RAW_TMP_REGNUM   = 34,    /* Temporary */
 513   MEP_RAW_EPC_REGNUM   = 35,    /* Exception program counter */
 514   MEP_RAW_EXC_REGNUM   = 36,    /* Raw exception cause */
 515   MEP_RAW_CFG_REGNUM   = 37,    /* Raw processor configuration*/
 516   MEP_RAW_CSR22_REGNUM = 38,    /* csr3: reserved */
 517   MEP_RAW_NPC_REGNUM   = 39,    /* Nonmaskable interrupt PC */
 518   MEP_RAW_DBG_REGNUM   = 40,    /* Raw debug */
 519   MEP_RAW_DEPC_REGNUM  = 41,    /* Debug exception PC */
 520   MEP_RAW_OPT_REGNUM   = 42,    /* Raw options */
 521   MEP_RAW_RCFG_REGNUM  = 43,    /* Raw local ram config */
 522   MEP_RAW_CCFG_REGNUM  = 44,    /* Raw cache config */
 523   MEP_RAW_CSR29_REGNUM = 45,    /* csr3: reserved */
 524   MEP_RAW_CSR30_REGNUM = 46,    /* csr3: reserved */
 525   MEP_RAW_CSR31_REGNUM = 47,    /* csr3: reserved */
 526   MEP_LAST_RAW_CSR_REGNUM = MEP_RAW_CSR31_REGNUM,
 527
 528   /* The raw coprocessor general-purpose registers.  These are all 64
 529      bits wide.  */
 530   MEP_FIRST_RAW_CR_REGNUM = 48,
 531   MEP_LAST_RAW_CR_REGNUM = MEP_FIRST_RAW_CR_REGNUM + 31,
 532
 533   MEP_FIRST_RAW_CCR_REGNUM = 80,
 534   MEP_LAST_RAW_CCR_REGNUM = MEP_FIRST_RAW_CCR_REGNUM + 63,
 535
 536   /* The module number register.  This is the index of the me_module
 537      of which the current target is an instance.  (This is not a real
 538      MeP-specified register; it's provided by SID.)  */
 539   MEP_MODULE_REGNUM,
 540
 541   MEP_LAST_RAW_REGNUM = MEP_MODULE_REGNUM,
 542
 543   MEP_NUM_RAW_REGS = MEP_LAST_RAW_REGNUM + 1,
 544
 545   /* Pseudoregisters.  See mep_pseudo_register_read and
 546      mep_pseudo_register_write.  */
 547   MEP_FIRST_PSEUDO_REGNUM = MEP_NUM_RAW_REGS,
 548
 549   /* We have a pseudoregister for every control/special register, to
 550      implement registers with read-only bits.  */
 551   MEP_FIRST_CSR_REGNUM = MEP_FIRST_PSEUDO_REGNUM,
 552   MEP_PC_REGNUM = MEP_FIRST_CSR_REGNUM, /* Program counter */
 553   MEP_LP_REGNUM,                /* Link pointer */
 554   MEP_SAR_REGNUM,               /* shift amount */
 555   MEP_CSR3_REGNUM,              /* csr3: reserved */
 556   MEP_RPB_REGNUM,               /* repeat begin address */
 557   MEP_RPE_REGNUM,               /* Repeat end address */
 558   MEP_RPC_REGNUM,               /* Repeat count */
 559   MEP_HI_REGNUM,  /* Upper 32 bits of the result of 64 bit mult/div */
 560   MEP_LO_REGNUM,  /* Lower 32 bits of the result of 64 bit mult/div */
 561   MEP_CSR9_REGNUM,              /* csr3: reserved */
 562   MEP_CSR10_REGNUM,             /* csr3: reserved */
 563   MEP_CSR11_REGNUM,             /* csr3: reserved */
 564   MEP_MB0_REGNUM,               /* modulo begin address 0 */
 565   MEP_ME0_REGNUM,               /* modulo end address 0 */
 566   MEP_MB1_REGNUM,               /* modulo begin address 1 */
 567   MEP_ME1_REGNUM,               /* modulo end address 1 */
 568   MEP_PSW_REGNUM,               /* program status word */
 569   MEP_ID_REGNUM,                /* processor ID/revision */
 570   MEP_TMP_REGNUM,               /* Temporary */
 571   MEP_EPC_REGNUM,               /* Exception program counter */
 572   MEP_EXC_REGNUM,               /* exception cause */
 573   MEP_CFG_REGNUM,               /* processor configuration*/
 574   MEP_CSR22_REGNUM,             /* csr3: reserved */
 575   MEP_NPC_REGNUM,               /* Nonmaskable interrupt PC */
 576   MEP_DBG_REGNUM,               /* debug */
 577   MEP_DEPC_REGNUM,              /* Debug exception PC */
 578   MEP_OPT_REGNUM,               /* options */
 579   MEP_RCFG_REGNUM,              /* local ram config */
 580   MEP_CCFG_REGNUM,              /* cache config */
 581   MEP_CSR29_REGNUM,             /* csr3: reserved */
 582   MEP_CSR30_REGNUM,             /* csr3: reserved */
 583   MEP_CSR31_REGNUM,             /* csr3: reserved */
 584   MEP_LAST_CSR_REGNUM = MEP_CSR31_REGNUM,
 585
 586   /* The 32-bit integer view of the coprocessor GPR's.  */
 587   MEP_FIRST_CR32_REGNUM,
 588   MEP_LAST_CR32_REGNUM = MEP_FIRST_CR32_REGNUM + 31,
 589
 590   /* The 32-bit floating-point view of the coprocessor GPR's.  */
 591   MEP_FIRST_FP_CR32_REGNUM,
 592   MEP_LAST_FP_CR32_REGNUM = MEP_FIRST_FP_CR32_REGNUM + 31,
 593
 594   /* The 64-bit integer view of the coprocessor GPR's.  */
 595   MEP_FIRST_CR64_REGNUM,
 596   MEP_LAST_CR64_REGNUM = MEP_FIRST_CR64_REGNUM + 31,
 597
 598   /* The 64-bit floating-point view of the coprocessor GPR's.  */
 599   MEP_FIRST_FP_CR64_REGNUM,
 600   MEP_LAST_FP_CR64_REGNUM = MEP_FIRST_FP_CR64_REGNUM + 31,
 601
 602   MEP_FIRST_CCR_REGNUM,
 603   MEP_LAST_CCR_REGNUM = MEP_FIRST_CCR_REGNUM + 63,
 604
 605   MEP_LAST_PSEUDO_REGNUM = MEP_LAST_CCR_REGNUM,
 606
 607   MEP_NUM_PSEUDO_REGS = (MEP_LAST_PSEUDO_REGNUM - MEP_LAST_RAW_REGNUM),
 608
 609   MEP_NUM_REGS = MEP_NUM_RAW_REGS + MEP_NUM_PSEUDO_REGS
 610 };
 611
 612
 613 #define IN_SET(set, n) \
 614   (MEP_FIRST_ ## set ## _REGNUM <= (n) && (n) <= MEP_LAST_ ## set ## _REGNUM)
 615
 616 #define IS_GPR_REGNUM(n)     (IN_SET (GPR,     (n)))
 617 #define IS_RAW_CSR_REGNUM(n) (IN_SET (RAW_CSR, (n)))
 618 #define IS_RAW_CR_REGNUM(n)  (IN_SET (RAW_CR,  (n)))
 619 #define IS_RAW_CCR_REGNUM(n) (IN_SET (RAW_CCR, (n)))
 620
 621 #define IS_CSR_REGNUM(n)     (IN_SET (CSR,     (n)))
 622 #define IS_CR32_REGNUM(n)    (IN_SET (CR32,    (n)))
 623 #define IS_FP_CR32_REGNUM(n) (IN_SET (FP_CR32, (n)))
 624 #define IS_CR64_REGNUM(n)    (IN_SET (CR64,    (n)))
 625 #define IS_FP_CR64_REGNUM(n) (IN_SET (FP_CR64, (n)))
 626 #define IS_CR_REGNUM(n)      (IS_CR32_REGNUM (n) || IS_FP_CR32_REGNUM (n) \
 627                               || IS_CR64_REGNUM (n) || IS_FP_CR64_REGNUM (n))
 628 #define IS_CCR_REGNUM(n)     (IN_SET (CCR,     (n)))
 629
 630 #define IS_RAW_REGNUM(n)     (IN_SET (RAW,     (n)))
 631 #define IS_PSEUDO_REGNUM(n)  (IN_SET (PSEUDO,  (n)))
 632
 633 #define NUM_REGS_IN_SET(set) \
 634   (MEP_LAST_ ## set ## _REGNUM - MEP_FIRST_ ## set ## _REGNUM + 1)
 635
 636 #define MEP_GPR_SIZE (4)        /* Size of a MeP general-purpose register.  */
 637 #define MEP_PSW_SIZE (4)        /* Size of the PSW register.  */
 638 #define MEP_LP_SIZE (4)         /* Size of the LP register.  */
 639
 640
 641 /* Many of the control/special registers contain bits that cannot be
 642    written to; some are entirely read-only.  So we present them all as
 643    pseudoregisters.
 644
 645    The following table describes the special properties of each CSR.  */
 646 struct mep_csr_register
 647 {
 648   /* The number of this CSR's raw register.  */
 649   int raw;
 650
 651   /* The number of this CSR's pseudoregister.  */
 652   int pseudo;
 653
 654   /* A mask of the bits that are writeable: if a bit is set here, then
 655      it can be modified; if the bit is clear, then it cannot.  */
 656   LONGEST writeable_bits;
 657 };
 658
 659
 660 /* mep_csr_registers[i] describes the i'th CSR.
 661    We just list the register numbers here explicitly to help catch
 662    typos.  */
 663 #define CSR(name) MEP_RAW_ ## name ## _REGNUM, MEP_ ## name ## _REGNUM
 664 struct mep_csr_register mep_csr_registers[] = {
 665   { CSR(PC),    0xffffffff },   /* manual says r/o, but we can write it */
 666   { CSR(LP),    0xffffffff },
 667   { CSR(SAR),   0x0000003f },
 668   { CSR(CSR3),  0xffffffff },
 669   { CSR(RPB),   0xfffffffe },
 670   { CSR(RPE),   0xffffffff },
 671   { CSR(RPC),   0xffffffff },
 672   { CSR(HI),    0xffffffff },
 673   { CSR(LO),    0xffffffff },
 674   { CSR(CSR9),  0xffffffff },
 675   { CSR(CSR10), 0xffffffff },
 676   { CSR(CSR11), 0xffffffff },
 677   { CSR(MB0),   0x0000ffff },
 678   { CSR(ME0),   0x0000ffff },
 679   { CSR(MB1),   0x0000ffff },
 680   { CSR(ME1),   0x0000ffff },
 681   { CSR(PSW),   0x000003ff },
 682   { CSR(ID),    0x00000000 },
 683   { CSR(TMP),   0xffffffff },
 684   { CSR(EPC),   0xffffffff },
 685   { CSR(EXC),   0x000030f0 },
 686   { CSR(CFG),   0x00c0001b },
 687   { CSR(CSR22), 0xffffffff },
 688   { CSR(NPC),   0xffffffff },
 689   { CSR(DBG),   0x00000580 },
 690   { CSR(DEPC),  0xffffffff },
 691   { CSR(OPT),   0x00000000 },
 692   { CSR(RCFG),  0x00000000 },
 693   { CSR(CCFG),  0x00000000 },
 694   { CSR(CSR29), 0xffffffff },
 695   { CSR(CSR30), 0xffffffff },
 696   { CSR(CSR31), 0xffffffff },
 697 };
 698
 699
 700 /* If R is the number of a raw register, then mep_raw_to_pseudo[R] is
 701    the number of the corresponding pseudoregister.  Otherwise,
 702    mep_raw_to_pseudo[R] == R.  */
 703 static int mep_raw_to_pseudo[MEP_NUM_REGS];
 704
 705 /* If R is the number of a pseudoregister, then mep_pseudo_to_raw[R]
 706    is the number of the underlying raw register.  Otherwise
 707    mep_pseudo_to_raw[R] == R.  */
 708 static int mep_pseudo_to_raw[MEP_NUM_REGS];
 709
 710 static void
 711 mep_init_pseudoregister_maps (void)
 712 {
 713   int i;
 714
 715   /* Verify that mep_csr_registers covers all the CSRs, in order.  */
 716   gdb_assert (ARRAY_SIZE (mep_csr_registers) == NUM_REGS_IN_SET (CSR));
 717   gdb_assert (ARRAY_SIZE (mep_csr_registers) == NUM_REGS_IN_SET (RAW_CSR));
 718
 719   /* Verify that the raw and pseudo ranges have matching sizes.  */
 720   gdb_assert (NUM_REGS_IN_SET (RAW_CSR) == NUM_REGS_IN_SET (CSR));
 721   gdb_assert (NUM_REGS_IN_SET (RAW_CR)  == NUM_REGS_IN_SET (CR32));
 722   gdb_assert (NUM_REGS_IN_SET (RAW_CR)  == NUM_REGS_IN_SET (CR64));
 723   gdb_assert (NUM_REGS_IN_SET (RAW_CCR) == NUM_REGS_IN_SET (CCR));
 724
 725   for (i = 0; i < ARRAY_SIZE (mep_csr_registers); i++)
 726     {
 727       struct mep_csr_register *r = &mep_csr_registers[i];
 728
 729       gdb_assert (r->pseudo == MEP_FIRST_CSR_REGNUM + i);
 730       gdb_assert (r->raw    == MEP_FIRST_RAW_CSR_REGNUM + i);
 731     }
 732
 733   /* Set up the initial  raw<->pseudo mappings.  */
 734   for (i = 0; i < MEP_NUM_REGS; i++)
 735     {
 736       mep_raw_to_pseudo[i] = i;
 737       mep_pseudo_to_raw[i] = i;
 738     }
 739
 740   /* Add the CSR raw<->pseudo mappings.  */
 741   for (i = 0; i < ARRAY_SIZE (mep_csr_registers); i++)
 742     {
 743       struct mep_csr_register *r = &mep_csr_registers[i];
 744
 745       mep_raw_to_pseudo[r->raw] = r->pseudo;
 746       mep_pseudo_to_raw[r->pseudo] = r->raw;
 747     }
 748
 749   /* Add the CR raw<->pseudo mappings.  */
 750   for (i = 0; i < NUM_REGS_IN_SET (RAW_CR); i++)
 751     {
 752       int raw = MEP_FIRST_RAW_CR_REGNUM + i;
 753       int pseudo32 = MEP_FIRST_CR32_REGNUM + i;
 754       int pseudofp32 = MEP_FIRST_FP_CR32_REGNUM + i;
 755       int pseudo64 = MEP_FIRST_CR64_REGNUM + i;
 756       int pseudofp64 = MEP_FIRST_FP_CR64_REGNUM + i;
 757
 758       /* Truly, the raw->pseudo mapping depends on the current module.
 759          But we use the raw->pseudo mapping when we read the debugging
 760          info; at that point, we don't know what module we'll actually
 761          be running yet.  So, we always supply the 64-bit register
 762          numbers; GDB knows how to pick a smaller value out of a
 763          larger register properly.  */
 764       mep_raw_to_pseudo[raw] = pseudo64;
 765       mep_pseudo_to_raw[pseudo32] = raw;
 766       mep_pseudo_to_raw[pseudofp32] = raw;
 767       mep_pseudo_to_raw[pseudo64] = raw;
 768       mep_pseudo_to_raw[pseudofp64] = raw;
 769     }
 770
 771   /* Add the CCR raw<->pseudo mappings.  */
 772   for (i = 0; i < NUM_REGS_IN_SET (CCR); i++)
 773     {
 774       int raw = MEP_FIRST_RAW_CCR_REGNUM + i;
 775       int pseudo = MEP_FIRST_CCR_REGNUM + i;
 776       mep_raw_to_pseudo[raw] = pseudo;
 777       mep_pseudo_to_raw[pseudo] = raw;
 778     }
 779 }
 780
 781
 782 static int
 783 mep_debug_reg_to_regnum (struct gdbarch *gdbarch, int debug_reg)
 784 {
 785   /* The debug info uses the raw register numbers.  */
 786   if (debug_reg >= 0 && debug_reg < ARRAY_SIZE (mep_raw_to_pseudo))
 787     return mep_raw_to_pseudo[debug_reg];
 788   return -1;
 789 }
 790
 791
 792 /* Return the size, in bits, of the coprocessor pseudoregister
 793    numbered PSEUDO.  */
 794 static int
 795 mep_pseudo_cr_size (int pseudo)
 796 {
 797   if (IS_CR32_REGNUM (pseudo)
 798       || IS_FP_CR32_REGNUM (pseudo))
 799     return 32;
 800   else if (IS_CR64_REGNUM (pseudo)
 801            || IS_FP_CR64_REGNUM (pseudo))
 802     return 64;
 803   else
 804     gdb_assert_not_reached ("unexpected coprocessor pseudo register");
 805 }
 806
 807
 808 /* If the coprocessor pseudoregister numbered PSEUDO is a
 809    floating-point register, return non-zero; if it is an integer
 810    register, return zero.  */
 811 static int
 812 mep_pseudo_cr_is_float (int pseudo)
 813 {
 814   return (IS_FP_CR32_REGNUM (pseudo)
 815           || IS_FP_CR64_REGNUM (pseudo));
 816 }
 817
 818
 819 /* Given a coprocessor GPR pseudoregister number, return its index
 820    within that register bank.  */
 821 static int
 822 mep_pseudo_cr_index (int pseudo)
 823 {
 824   if (IS_CR32_REGNUM (pseudo))
 825     return pseudo - MEP_FIRST_CR32_REGNUM;
 826   else if (IS_FP_CR32_REGNUM (pseudo))
 827       return pseudo - MEP_FIRST_FP_CR32_REGNUM;
 828   else if (IS_CR64_REGNUM (pseudo))
 829       return pseudo - MEP_FIRST_CR64_REGNUM;
 830   else if (IS_FP_CR64_REGNUM (pseudo))
 831       return pseudo - MEP_FIRST_FP_CR64_REGNUM;
 832   else
 833     gdb_assert_not_reached ("unexpected coprocessor pseudo register");
 834 }
 835
 836
 837 /* Return the me_module index describing the current target.
 838
 839    If the current target has registers (e.g., simulator, remote
 840    target), then this uses the value of the 'module' register, raw
 841    register MEP_MODULE_REGNUM.  Otherwise, this retrieves the value
 842    from the ELF header's e_flags field of the current executable
 843    file.  */
 844 static CONFIG_ATTR
 845 current_me_module (void)
 846 {
 847   if (target_has_registers)
 848     {
 849       ULONGEST regval;
 850       regcache_cooked_read_unsigned (get_current_regcache (),
 851                                      MEP_MODULE_REGNUM, &regval);
 852       return (CONFIG_ATTR) regval;
 853     }
 854   else
 855     return gdbarch_tdep (target_gdbarch ())->me_module;
 856 }
 857
 858
 859 /* Return the set of options for the current target, in the form that
 860    the OPT register would use.
 861
 862    If the current target has registers (e.g., simulator, remote
 863    target), then this is the actual value of the OPT register.  If the
 864    current target does not have registers (e.g., an executable file),
 865    then use the 'module_opt' field we computed when we build the
 866    gdbarch object for this module.  */
 867 static unsigned int
 868 current_options (void)
 869 {
 870   if (target_has_registers)
 871     {
 872       ULONGEST regval;
 873       regcache_cooked_read_unsigned (get_current_regcache (),
 874                                      MEP_OPT_REGNUM, &regval);
 875       return regval;
 876     }
 877   else
 878     return me_module_opt (current_me_module ());
 879 }
 880
 881
 882 /* Return the width of the current me_module's coprocessor data bus,
 883    in bits.  This is either 32 or 64.  */
 884 static int
 885 current_cop_data_bus_width (void)
 886 {
 887   return me_module_cop_data_bus_width (current_me_module ());
 888 }
 889
 890
 891 /* Return the keyword table of coprocessor general-purpose register
 892    names appropriate for the me_module we're dealing with.  */
 893 static CGEN_KEYWORD *
 894 current_cr_names (void)
 895 {
 896   const CGEN_HW_ENTRY *hw
 897     = me_module_register_set (current_me_module (), "h-cr-", HW_H_CR);
 898
 899   return register_set_keyword_table (hw);
 900 }
 901
 902
 903 /* Return non-zero if the coprocessor general-purpose registers are
 904    floating-point values, zero otherwise.  */
 905 static int
 906 current_cr_is_float (void)
 907 {
 908   const CGEN_HW_ENTRY *hw
 909     = me_module_register_set (current_me_module (), "h-cr-", HW_H_CR);
 910
 911   return CGEN_ATTR_CGEN_HW_IS_FLOAT_VALUE (CGEN_HW_ATTRS (hw));
 912 }
 913
 914
 915 /* Return the keyword table of coprocessor control register names
 916    appropriate for the me_module we're dealing with.  */
 917 static CGEN_KEYWORD *
 918 current_ccr_names (void)
 919 {
 920   const CGEN_HW_ENTRY *hw
 921     = me_module_register_set (current_me_module (), "h-ccr-", HW_H_CCR);
 922
 923   return register_set_keyword_table (hw);
 924 }
 925
 926
 927 static const char *
 928 mep_register_name (struct gdbarch *gdbarch, int regnr)
 929 {
 930   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 931
 932   /* General-purpose registers.  */
 933   static const char *gpr_names[] = {
 934     "r0",   "r1",   "r2",   "r3",   /* 0 */
 935     "r4",   "r5",   "r6",   "r7",   /* 4 */
 936     "fp",   "r9",   "r10",  "r11",  /* 8 */
 937     "r12",  "tp",   "gp",   "sp"    /* 12 */
 938   };
 939
 940   /* Special-purpose registers.  */
 941   static const char *csr_names[] = {
 942     "pc",   "lp",   "sar",  "",     /* 0  csr3: reserved */
 943     "rpb",  "rpe",  "rpc",  "hi",   /* 4 */
 944     "lo",   "",     "",     "",     /* 8  csr9-csr11: reserved */
 945     "mb0",  "me0",  "mb1",  "me1",  /* 12 */
 946
 947     "psw",  "id",   "tmp",  "epc",  /* 16 */
 948     "exc",  "cfg",  "",     "npc",  /* 20  csr22: reserved */
 949     "dbg",  "depc", "opt",  "rcfg", /* 24 */
 950     "ccfg", "",     "",     ""      /* 28  csr29-csr31: reserved */
 951   };
 952
 953   if (IS_GPR_REGNUM (regnr))
 954     return gpr_names[regnr - MEP_R0_REGNUM];
 955   else if (IS_CSR_REGNUM (regnr))
 956     {
 957       /* The 'hi' and 'lo' registers are only present on processors
 958          that have the 'MUL' or 'DIV' instructions enabled.  */
 959       if ((regnr == MEP_HI_REGNUM || regnr == MEP_LO_REGNUM)
 960           && (! (current_options () & (MEP_OPT_MUL | MEP_OPT_DIV))))
 961         return "";
 962
 963       return csr_names[regnr - MEP_FIRST_CSR_REGNUM];
 964     }
 965   else if (IS_CR_REGNUM (regnr))
 966     {
 967       CGEN_KEYWORD *names;
 968       int cr_size;
 969       int cr_is_float;
 970
 971       /* Does this module have a coprocessor at all?  */
 972       if (! (current_options () & MEP_OPT_COP))
 973         return "";
 974
 975       names = current_cr_names ();
 976       if (! names)
 977         /* This module's coprocessor has no general-purpose registers.  */
 978         return "";
 979
 980       cr_size = current_cop_data_bus_width ();
 981       if (cr_size != mep_pseudo_cr_size (regnr))
 982         /* This module's coprocessor's GPR's are of a different size.  */
 983         return "";
 984
 985       cr_is_float = current_cr_is_float ();
 986       /* The extra ! operators ensure we get boolean equality, not
 987          numeric equality.  */
 988       if (! cr_is_float != ! mep_pseudo_cr_is_float (regnr))
 989         /* This module's coprocessor's GPR's are of a different type.  */
 990         return "";
 991
 992       return register_name_from_keyword (names, mep_pseudo_cr_index (regnr));
 993     }
 994   else if (IS_CCR_REGNUM (regnr))
 995     {
 996       /* Does this module have a coprocessor at all?  */
 997       if (! (current_options () & MEP_OPT_COP))
 998         return "";
 999
1000       {
1001         CGEN_KEYWORD *names = current_ccr_names ();
1002
1003         if (! names)
1004           /* This me_module's coprocessor has no control registers.  */
1005           return "";
1006
1007         return register_name_from_keyword (names, regnr-MEP_FIRST_CCR_REGNUM);
1008       }
1009     }
1010
1011   /* It might be nice to give the 'module' register a name, but that
1012      would affect the output of 'info all-registers', which would
1013      disturb the test suites.  So we leave it invisible.  */
1014   else
1015     return NULL;
1016 }
1017
1018
1019 /* Custom register groups for the MeP.  */
1020 static struct reggroup *mep_csr_reggroup; /* control/special */
1021 static struct reggroup *mep_cr_reggroup;  /* coprocessor general-purpose */
1022 static struct reggroup *mep_ccr_reggroup; /* coprocessor control */
1023
1024
1025 static int
1026 mep_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
1027                          struct reggroup *group)
1028 {
1029   /* Filter reserved or unused register numbers.  */
1030   {
1031     const char *name = mep_register_name (gdbarch, regnum);
1032
1033     if (! name || name[0] == '\0')
1034       return 0;
1035   }
1036
1037   /* We could separate the GPRs and the CSRs.  Toshiba has approved of
1038      the existing behavior, so we'd want to run that by them.  */
1039   if (group == general_reggroup)
1040     return (IS_GPR_REGNUM (regnum)
1041             || IS_CSR_REGNUM (regnum));
1042
1043   /* Everything is in the 'all' reggroup, except for the raw CSR's.  */
1044   else if (group == all_reggroup)
1045     return (IS_GPR_REGNUM (regnum)
1046             || IS_CSR_REGNUM (regnum)
1047             || IS_CR_REGNUM (regnum)
1048             || IS_CCR_REGNUM (regnum));
1049
1050   /* All registers should be saved and restored, except for the raw
1051      CSR's.
1052
1053      This is probably right if the coprocessor is something like a
1054      floating-point unit, but would be wrong if the coprocessor is
1055      something that does I/O, where register accesses actually cause
1056      externally-visible actions.  But I get the impression that the
1057      coprocessor isn't supposed to do things like that --- you'd use a
1058      hardware engine, perhaps.  */
1059   else if (group == save_reggroup || group == restore_reggroup)
1060     return (IS_GPR_REGNUM (regnum)
1061             || IS_CSR_REGNUM (regnum)
1062             || IS_CR_REGNUM (regnum)
1063             || IS_CCR_REGNUM (regnum));
1064
1065   else if (group == mep_csr_reggroup)
1066     return IS_CSR_REGNUM (regnum);
1067   else if (group == mep_cr_reggroup)
1068     return IS_CR_REGNUM (regnum);
1069   else if (group == mep_ccr_reggroup)
1070     return IS_CCR_REGNUM (regnum);
1071   else
1072     return 0;
1073 }
1074
1075
1076 static struct type *
1077 mep_register_type (struct gdbarch *gdbarch, int reg_nr)
1078 {
1079   /* Coprocessor general-purpose registers may be either 32 or 64 bits
1080      long.  So for them, the raw registers are always 64 bits long (to
1081      keep the 'g' packet format fixed), and the pseudoregisters vary
1082      in length.  */
1083   if (IS_RAW_CR_REGNUM (reg_nr))
1084     return builtin_type (gdbarch)->builtin_uint64;
1085
1086   /* Since GDB doesn't allow registers to change type, we have two
1087      banks of pseudoregisters for the coprocessor general-purpose
1088      registers: one that gives a 32-bit view, and one that gives a
1089      64-bit view.  We hide or show one or the other depending on the
1090      current module.  */
1091   if (IS_CR_REGNUM (reg_nr))
1092     {
1093       int size = mep_pseudo_cr_size (reg_nr);
1094       if (size == 32)
1095         {
1096           if (mep_pseudo_cr_is_float (reg_nr))
1097             return builtin_type (gdbarch)->builtin_float;
1098           else
1099             return builtin_type (gdbarch)->builtin_uint32;
1100         }
1101       else if (size == 64)
1102         {
1103           if (mep_pseudo_cr_is_float (reg_nr))
1104             return builtin_type (gdbarch)->builtin_double;
1105           else
1106             return builtin_type (gdbarch)->builtin_uint64;
1107         }
1108       else
1109         gdb_assert_not_reached ("unexpected cr size");
1110     }
1111
1112   /* All other registers are 32 bits long.  */
1113   else
1114     return builtin_type (gdbarch)->builtin_uint32;
1115 }
1116
1117
1118 static CORE_ADDR
1119 mep_read_pc (struct regcache *regcache)
1120 {
1121   ULONGEST pc;
1122   regcache_cooked_read_unsigned (regcache, MEP_PC_REGNUM, &pc);
1123   return pc;
1124 }
1125
1126 static enum register_status
1127 mep_pseudo_cr32_read (struct gdbarch *gdbarch,
1128                       struct regcache *regcache,
1129                       int cookednum,
1130                       gdb_byte *buf)
1131 {
1132   enum register_status status;
1133   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1134   /* Read the raw register into a 64-bit buffer, and then return the
1135      appropriate end of that buffer.  */
1136   int rawnum = mep_pseudo_to_raw[cookednum];
1137   gdb_byte buf64[8];
1138
1139   gdb_assert (TYPE_LENGTH (register_type (gdbarch, rawnum)) == sizeof (buf64));
1140   gdb_assert (TYPE_LENGTH (register_type (gdbarch, cookednum)) == 4);
1141   status = regcache_raw_read (regcache, rawnum, buf64);
1142   if (status == REG_VALID)
1143     {
1144       /* Slow, but legible.  */
1145       store_unsigned_integer (buf, 4, byte_order,
1146                               extract_unsigned_integer (buf64, 8, byte_order));
1147     }
1148   return status;
1149 }
1150
1151
1152 static enum register_status
1153 mep_pseudo_cr64_read (struct gdbarch *gdbarch,
1154                       struct regcache *regcache,
1155                       int cookednum,
1156                       gdb_byte *buf)
1157 {
1158   return regcache_raw_read (regcache, mep_pseudo_to_raw[cookednum], buf);
1159 }
1160
1161
1162 static enum register_status
1163 mep_pseudo_register_read (struct gdbarch *gdbarch,
1164                           struct regcache *regcache,
1165                           int cookednum,
1166                           gdb_byte *buf)
1167 {
1168   if (IS_CSR_REGNUM (cookednum)
1169       || IS_CCR_REGNUM (cookednum))
1170     return regcache_raw_read (regcache, mep_pseudo_to_raw[cookednum], buf);
1171   else if (IS_CR32_REGNUM (cookednum)
1172            || IS_FP_CR32_REGNUM (cookednum))
1173     return mep_pseudo_cr32_read (gdbarch, regcache, cookednum, buf);
1174   else if (IS_CR64_REGNUM (cookednum)
1175            || IS_FP_CR64_REGNUM (cookednum))
1176     return mep_pseudo_cr64_read (gdbarch, regcache, cookednum, buf);
1177   else
1178     gdb_assert_not_reached ("unexpected pseudo register");
1179 }
1180
1181
1182 static void
1183 mep_pseudo_csr_write (struct gdbarch *gdbarch,
1184                       struct regcache *regcache,
1185                       int cookednum,
1186                       const gdb_byte *buf)
1187 {
1188   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1189   int size = register_size (gdbarch, cookednum);
1190   struct mep_csr_register *r
1191     = &mep_csr_registers[cookednum - MEP_FIRST_CSR_REGNUM];
1192
1193   if (r->writeable_bits == 0)
1194     /* A completely read-only register; avoid the read-modify-
1195        write cycle, and juts ignore the entire write.  */
1196     ;
1197   else
1198     {
1199       /* A partially writeable register; do a read-modify-write cycle.  */
1200       ULONGEST old_bits;
1201       ULONGEST new_bits;
1202       ULONGEST mixed_bits;
1203
1204       regcache_raw_read_unsigned (regcache, r->raw, &old_bits);
1205       new_bits = extract_unsigned_integer (buf, size, byte_order);
1206       mixed_bits = ((r->writeable_bits & new_bits)
1207                     | (~r->writeable_bits & old_bits));
1208       regcache_raw_write_unsigned (regcache, r->raw, mixed_bits);
1209     }
1210 }
1211
1212
1213 static void
1214 mep_pseudo_cr32_write (struct gdbarch *gdbarch,
1215                        struct regcache *regcache,
1216                        int cookednum,
1217                        const gdb_byte *buf)
1218 {
1219   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1220   /* Expand the 32-bit value into a 64-bit value, and write that to
1221      the pseudoregister.  */
1222   int rawnum = mep_pseudo_to_raw[cookednum];
1223   gdb_byte buf64[8];
1224
1225   gdb_assert (TYPE_LENGTH (register_type (gdbarch, rawnum)) == sizeof (buf64));
1226   gdb_assert (TYPE_LENGTH (register_type (gdbarch, cookednum)) == 4);
1227   /* Slow, but legible.  */
1228   store_unsigned_integer (buf64, 8, byte_order,
1229                           extract_unsigned_integer (buf, 4, byte_order));
1230   regcache_raw_write (regcache, rawnum, buf64);
1231 }
1232
1233
1234 static void
1235 mep_pseudo_cr64_write (struct gdbarch *gdbarch,
1236                      struct regcache *regcache,
1237                      int cookednum,
1238                      const gdb_byte *buf)
1239 {
1240   regcache_raw_write (regcache, mep_pseudo_to_raw[cookednum], buf);
1241 }
1242
1243
1244 static void
1245 mep_pseudo_register_write (struct gdbarch *gdbarch,
1246                            struct regcache *regcache,
1247                            int cookednum,
1248                            const gdb_byte *buf)
1249 {
1250   if (IS_CSR_REGNUM (cookednum))
1251     mep_pseudo_csr_write (gdbarch, regcache, cookednum, buf);
1252   else if (IS_CR32_REGNUM (cookednum)
1253            || IS_FP_CR32_REGNUM (cookednum))
1254     mep_pseudo_cr32_write (gdbarch, regcache, cookednum, buf);
1255   else if (IS_CR64_REGNUM (cookednum)
1256            || IS_FP_CR64_REGNUM (cookednum))
1257     mep_pseudo_cr64_write (gdbarch, regcache, cookednum, buf);
1258   else if (IS_CCR_REGNUM (cookednum))
1259     regcache_raw_write (regcache, mep_pseudo_to_raw[cookednum], buf);
1260   else
1261     gdb_assert_not_reached ("unexpected pseudo register");
1262 }
1263
1264
1265 \f
1266 /* Disassembly.  */
1267
1268 static int
1269 mep_gdb_print_insn (bfd_vma pc, disassemble_info * info)
1270 {
1271   struct obj_section * s = find_pc_section (pc);
1272
1273   info->arch = bfd_arch_mep;
1274   if (s)
1275     {
1276       /* The libopcodes disassembly code uses the section to find the
1277          BFD, the BFD to find the ELF header, the ELF header to find
1278          the me_module index, and the me_module index to select the
1279          right instructions to print.  */
1280       info->section = s->the_bfd_section;
1281     }
1282
1283   return print_insn_mep (pc, info);
1284 }
1285
1286 \f
1287 /* Prologue analysis.  */
1288
1289
1290 /* The MeP has two classes of instructions: "core" instructions, which
1291    are pretty normal RISC chip stuff, and "coprocessor" instructions,
1292    which are mostly concerned with moving data in and out of
1293    coprocessor registers, and branching on coprocessor condition
1294    codes.  There's space in the instruction set for custom coprocessor
1295    instructions, too.
1296
1297    Instructions can be 16 or 32 bits long; the top two bits of the
1298    first byte indicate the length.  The coprocessor instructions are
1299    mixed in with the core instructions, and there's no easy way to
1300    distinguish them; you have to completely decode them to tell one
1301    from the other.
1302
1303    The MeP also supports a "VLIW" operation mode, where instructions
1304    always occur in fixed-width bundles.  The bundles are either 32
1305    bits or 64 bits long, depending on a fixed configuration flag.  You
1306    decode the first part of the bundle as normal; if it's a core
1307    instruction, and there's any space left in the bundle, the
1308    remainder of the bundle is a coprocessor instruction, which will
1309    execute in parallel with the core instruction.  If the first part
1310    of the bundle is a coprocessor instruction, it occupies the entire
1311    bundle.
1312
1313    So, here are all the cases:
1314
1315    - 32-bit VLIW mode:
1316      Every bundle is four bytes long, and naturally aligned, and can hold
1317      one or two instructions:
1318      - 16-bit core instruction; 16-bit coprocessor instruction
1319        These execute in parallel.
1320      - 32-bit core instruction
1321      - 32-bit coprocessor instruction
1322
1323    - 64-bit VLIW mode:
1324      Every bundle is eight bytes long, and naturally aligned, and can hold
1325      one or two instructions:
1326      - 16-bit core instruction; 48-bit (!) coprocessor instruction
1327        These execute in parallel.
1328      - 32-bit core instruction; 32-bit coprocessor instruction
1329        These execute in parallel.
1330      - 64-bit coprocessor instruction
1331
1332    Now, the MeP manual doesn't define any 48- or 64-bit coprocessor
1333    instruction, so I don't really know what's up there; perhaps these
1334    are always the user-defined coprocessor instructions.  */
1335
1336
1337 /* Return non-zero if PC is in a VLIW code section, zero
1338    otherwise.  */
1339 static int
1340 mep_pc_in_vliw_section (CORE_ADDR pc)
1341 {
1342   struct obj_section *s = find_pc_section (pc);
1343   if (s)
1344     return (s->the_bfd_section->flags & SEC_MEP_VLIW);
1345   return 0;
1346 }
1347
1348
1349 /* Set *INSN to the next core instruction at PC, and return the
1350    address of the next instruction.
1351
1352    The MeP instruction encoding is endian-dependent.  16- and 32-bit
1353    instructions are encoded as one or two two-byte parts, and each
1354    part is byte-swapped independently.  Thus:
1355
1356       void
1357       foo (void)
1358       {
1359         asm ("movu $1, 0x123456");
1360         asm ("sb $1,0x5678($2)");
1361         asm ("clip $1, 19");
1362       }
1363
1364    compiles to this big-endian code:
1365
1366        0:       d1 56 12 34     movu $1,0x123456
1367        4:       c1 28 56 78     sb $1,22136($2)
1368        8:       f1 01 10 98     clip $1,0x13
1369        c:       70 02           ret
1370
1371    and this little-endian code:
1372
1373        0:       56 d1 34 12     movu $1,0x123456
1374        4:       28 c1 78 56     sb $1,22136($2)
1375        8:       01 f1 98 10     clip $1,0x13
1376        c:       02 70           ret
1377
1378    Instructions are returned in *INSN in an endian-independent form: a
1379    given instruction always appears in *INSN the same way, regardless
1380    of whether the instruction stream is big-endian or little-endian.
1381
1382    *INSN's most significant 16 bits are the first (i.e., at lower
1383    addresses) 16 bit part of the instruction.  Its least significant
1384    16 bits are the second (i.e., higher-addressed) 16 bit part of the
1385    instruction, or zero for a 16-bit instruction.  Both 16-bit parts
1386    are fetched using the current endianness.
1387
1388    So, the *INSN values for the instruction sequence above would be
1389    the following, in either endianness:
1390
1391        0xd1561234       movu $1,0x123456
1392        0xc1285678       sb $1,22136($2)
1393        0xf1011098       clip $1,0x13
1394        0x70020000       ret
1395
1396    (In a sense, it would be more natural to return 16-bit instructions
1397    in the least significant 16 bits of *INSN, but that would be
1398    ambiguous.  In order to tell whether you're looking at a 16- or a
1399    32-bit instruction, you have to consult the major opcode field ---
1400    the most significant four bits of the instruction's first 16-bit
1401    part.  But if we put 16-bit instructions at the least significant
1402    end of *INSN, then you don't know where to find the major opcode
1403    field until you know if it's a 16- or a 32-bit instruction ---
1404    which is where we started.)
1405
1406    If PC points to a core / coprocessor bundle in a VLIW section, set
1407    *INSN to the core instruction, and return the address of the next
1408    bundle.  This has the effect of skipping the bundled coprocessor
1409    instruction.  That's okay, since coprocessor instructions aren't
1410    significant to prologue analysis --- for the time being,
1411    anyway.  */
1412
1413 static CORE_ADDR
1414 mep_get_insn (struct gdbarch *gdbarch, CORE_ADDR pc, unsigned long *insn)
1415 {
1416   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1417   int pc_in_vliw_section;
1418   int vliw_mode;
1419   int insn_len;
1420   gdb_byte buf[2];
1421
1422   *insn = 0;
1423
1424   /* Are we in a VLIW section?  */
1425   pc_in_vliw_section = mep_pc_in_vliw_section (pc);
1426   if (pc_in_vliw_section)
1427     {
1428       /* Yes, find out which bundle size.  */
1429       vliw_mode = current_options () & (MEP_OPT_VL32 | MEP_OPT_VL64);
1430
1431       /* If PC is in a VLIW section, but the current core doesn't say
1432          that it supports either VLIW mode, then we don't have enough
1433          information to parse the instruction stream it contains.
1434          Since the "undifferentiated" standard core doesn't have
1435          either VLIW mode bit set, this could happen.
1436
1437          But it shouldn't be an error to (say) set a breakpoint in a
1438          VLIW section, if you know you'll never reach it.  (Perhaps
1439          you have a script that sets a bunch of standard breakpoints.)
1440
1441          So we'll just return zero here, and hope for the best.  */
1442       if (! (vliw_mode & (MEP_OPT_VL32 | MEP_OPT_VL64)))
1443         return 0;
1444
1445       /* If both VL32 and VL64 are set, that's bogus, too.  */
1446       if (vliw_mode == (MEP_OPT_VL32 | MEP_OPT_VL64))
1447         return 0;
1448     }
1449   else
1450     vliw_mode = 0;
1451
1452   read_memory (pc, buf, sizeof (buf));
1453   *insn = extract_unsigned_integer (buf, 2, byte_order) << 16;
1454
1455   /* The major opcode --- the top four bits of the first 16-bit
1456      part --- indicates whether this instruction is 16 or 32 bits
1457      long.  All 32-bit instructions have a major opcode whose top
1458      two bits are 11; all the rest are 16-bit instructions.  */
1459   if ((*insn & 0xc0000000) == 0xc0000000)
1460     {
1461       /* Fetch the second 16-bit part of the instruction.  */
1462       read_memory (pc + 2, buf, sizeof (buf));
1463       *insn = *insn | extract_unsigned_integer (buf, 2, byte_order);
1464     }
1465
1466   /* If we're in VLIW code, then the VLIW width determines the address
1467      of the next instruction.  */
1468   if (vliw_mode)
1469     {
1470       /* In 32-bit VLIW code, all bundles are 32 bits long.  We ignore the
1471          coprocessor half of a core / copro bundle.  */
1472       if (vliw_mode == MEP_OPT_VL32)
1473         insn_len = 4;
1474
1475       /* In 64-bit VLIW code, all bundles are 64 bits long.  We ignore the
1476          coprocessor half of a core / copro bundle.  */
1477       else if (vliw_mode == MEP_OPT_VL64)
1478         insn_len = 8;
1479
1480       /* We'd better be in either core, 32-bit VLIW, or 64-bit VLIW mode.  */
1481       else
1482         gdb_assert_not_reached ("unexpected vliw mode");
1483     }
1484
1485   /* Otherwise, the top two bits of the major opcode are (again) what
1486      we need to check.  */
1487   else if ((*insn & 0xc0000000) == 0xc0000000)
1488     insn_len = 4;
1489   else
1490     insn_len = 2;
1491
1492   return pc + insn_len;
1493 }
1494
1495
1496 /* Sign-extend the LEN-bit value N.  */
1497 #define SEXT(n, len) ((((int) (n)) ^ (1 << ((len) - 1))) - (1 << ((len) - 1)))
1498
1499 /* Return the LEN-bit field at POS from I.  */
1500 #define FIELD(i, pos, len) (((i) >> (pos)) & ((1 << (len)) - 1))
1501
1502 /* Like FIELD, but sign-extend the field's value.  */
1503 #define SFIELD(i, pos, len) (SEXT (FIELD ((i), (pos), (len)), (len)))
1504
1505
1506 /* Macros for decoding instructions.
1507
1508    Remember that 16-bit instructions are placed in bits 16..31 of i,
1509    not at the least significant end; this means that the major opcode
1510    field is always in the same place, regardless of the width of the
1511    instruction.  As a reminder of this, we show the lower 16 bits of a
1512    16-bit instruction as xxxx_xxxx_xxxx_xxxx.  */
1513
1514 /* SB Rn,(Rm)                 0000_nnnn_mmmm_1000 */
1515 /* SH Rn,(Rm)                 0000_nnnn_mmmm_1001 */
1516 /* SW Rn,(Rm)                 0000_nnnn_mmmm_1010 */
1517
1518 /* SW Rn,disp16(Rm)           1100_nnnn_mmmm_1010 dddd_dddd_dddd_dddd */
1519 #define IS_SW(i)              (((i) & 0xf00f0000) == 0xc00a0000)
1520 /* SB Rn,disp16(Rm)           1100_nnnn_mmmm_1000 dddd_dddd_dddd_dddd */
1521 #define IS_SB(i)              (((i) & 0xf00f0000) == 0xc0080000)
1522 /* SH Rn,disp16(Rm)           1100_nnnn_mmmm_1001 dddd_dddd_dddd_dddd */
1523 #define IS_SH(i)              (((i) & 0xf00f0000) == 0xc0090000)
1524 #define SWBH_32_BASE(i)       (FIELD (i, 20, 4))
1525 #define SWBH_32_SOURCE(i)     (FIELD (i, 24, 4))
1526 #define SWBH_32_OFFSET(i)     (SFIELD (i, 0, 16))
1527
1528 /* SW Rn,disp7.align4(SP)     0100_nnnn_0ddd_dd10 xxxx_xxxx_xxxx_xxxx */
1529 #define IS_SW_IMMD(i)         (((i) & 0xf0830000) == 0x40020000)
1530 #define SW_IMMD_SOURCE(i)     (FIELD (i, 24, 4))
1531 #define SW_IMMD_OFFSET(i)     (FIELD (i, 18, 5) << 2)
1532
1533 /* SW Rn,(Rm)                 0000_nnnn_mmmm_1010 xxxx_xxxx_xxxx_xxxx */
1534 #define IS_SW_REG(i)          (((i) & 0xf00f0000) == 0x000a0000)
1535 #define SW_REG_SOURCE(i)      (FIELD (i, 24, 4))
1536 #define SW_REG_BASE(i)        (FIELD (i, 20, 4))
1537
1538 /* ADD3 Rl,Rn,Rm              1001_nnnn_mmmm_llll xxxx_xxxx_xxxx_xxxx */
1539 #define IS_ADD3_16_REG(i)     (((i) & 0xf0000000) == 0x90000000)
1540 #define ADD3_16_REG_SRC1(i)   (FIELD (i, 20, 4))               /* n */
1541 #define ADD3_16_REG_SRC2(i)   (FIELD (i, 24, 4))               /* m */
1542
1543 /* ADD3 Rn,Rm,imm16           1100_nnnn_mmmm_0000 iiii_iiii_iiii_iiii */
1544 #define IS_ADD3_32(i)         (((i) & 0xf00f0000) == 0xc0000000)
1545 #define ADD3_32_TARGET(i)     (FIELD (i, 24, 4))
1546 #define ADD3_32_SOURCE(i)     (FIELD (i, 20, 4))
1547 #define ADD3_32_OFFSET(i)     (SFIELD (i, 0, 16))
1548
1549 /* ADD3 Rn,SP,imm7.align4     0100_nnnn_0iii_ii00 xxxx_xxxx_xxxx_xxxx */
1550 #define IS_ADD3_16(i)         (((i) & 0xf0830000) == 0x40000000)
1551 #define ADD3_16_TARGET(i)     (FIELD (i, 24, 4))
1552 #define ADD3_16_OFFSET(i)     (FIELD (i, 18, 5) << 2)
1553
1554 /* ADD Rn,imm6                0110_nnnn_iiii_ii00 xxxx_xxxx_xxxx_xxxx */
1555 #define IS_ADD(i)             (((i) & 0xf0030000) == 0x60000000)
1556 #define ADD_TARGET(i)         (FIELD (i, 24, 4))
1557 #define ADD_OFFSET(i)         (SFIELD (i, 18, 6))
1558
1559 /* LDC Rn,imm5                0111_nnnn_iiii_101I xxxx_xxxx_xxxx_xxxx
1560                               imm5 = I||i[7:4] */
1561 #define IS_LDC(i)             (((i) & 0xf00e0000) == 0x700a0000)
1562 #define LDC_IMM(i)            ((FIELD (i, 16, 1) << 4) | FIELD (i, 20, 4))
1563 #define LDC_TARGET(i)         (FIELD (i, 24, 4))
1564
1565 /* LW Rn,disp16(Rm)           1100_nnnn_mmmm_1110 dddd_dddd_dddd_dddd  */
1566 #define IS_LW(i)              (((i) & 0xf00f0000) == 0xc00e0000)
1567 #define LW_TARGET(i)          (FIELD (i, 24, 4))
1568 #define LW_BASE(i)            (FIELD (i, 20, 4))
1569 #define LW_OFFSET(i)          (SFIELD (i, 0, 16))
1570
1571 /* MOV Rn,Rm                  0000_nnnn_mmmm_0000 xxxx_xxxx_xxxx_xxxx */
1572 #define IS_MOV(i)             (((i) & 0xf00f0000) == 0x00000000)
1573 #define MOV_TARGET(i)         (FIELD (i, 24, 4))
1574 #define MOV_SOURCE(i)         (FIELD (i, 20, 4))
1575
1576 /* BRA disp12.align2          1011_dddd_dddd_ddd0 xxxx_xxxx_xxxx_xxxx */
1577 #define IS_BRA(i)             (((i) & 0xf0010000) == 0xb0000000)
1578 #define BRA_DISP(i)           (SFIELD (i, 17, 11) << 1)
1579
1580
1581 /* This structure holds the results of a prologue analysis.  */
1582 struct mep_prologue
1583 {
1584   /* The architecture for which we generated this prologue info.  */
1585   struct gdbarch *gdbarch;
1586
1587   /* The offset from the frame base to the stack pointer --- always
1588      zero or negative.
1589
1590      Calling this a "size" is a bit misleading, but given that the
1591      stack grows downwards, using offsets for everything keeps one
1592      from going completely sign-crazy: you never change anything's
1593      sign for an ADD instruction; always change the second operand's
1594      sign for a SUB instruction; and everything takes care of
1595      itself.  */
1596   int frame_size;
1597
1598   /* Non-zero if this function has initialized the frame pointer from
1599      the stack pointer, zero otherwise.  */
1600   int has_frame_ptr;
1601
1602   /* If has_frame_ptr is non-zero, this is the offset from the frame
1603      base to where the frame pointer points.  This is always zero or
1604      negative.  */
1605   int frame_ptr_offset;
1606
1607   /* The address of the first instruction at which the frame has been
1608      set up and the arguments are where the debug info says they are
1609      --- as best as we can tell.  */
1610   CORE_ADDR prologue_end;
1611
1612   /* reg_offset[R] is the offset from the CFA at which register R is
1613      saved, or 1 if register R has not been saved.  (Real values are
1614      always zero or negative.)  */
1615   int reg_offset[MEP_NUM_REGS];
1616 };
1617
1618 /* Return non-zero if VALUE is an incoming argument register.  */
1619
1620 static int
1621 is_arg_reg (pv_t value)
1622 {
1623   return (value.kind == pvk_register
1624           && MEP_R1_REGNUM <= value.reg && value.reg <= MEP_R4_REGNUM
1625           && value.k == 0);
1626 }
1627
1628 /* Return non-zero if a store of REG's current value VALUE to ADDR is
1629    probably spilling an argument register to its stack slot in STACK.
1630    Such instructions should be included in the prologue, if possible.
1631
1632    The store is a spill if:
1633    - the value being stored is REG's original value;
1634    - the value has not already been stored somewhere in STACK; and
1635    - ADDR is a stack slot's address (e.g., relative to the original
1636      value of the SP).  */
1637 static int
1638 is_arg_spill (struct gdbarch *gdbarch, pv_t value, pv_t addr,
1639               struct pv_area *stack)
1640 {
1641   return (is_arg_reg (value)
1642           && pv_is_register (addr, MEP_SP_REGNUM)
1643           && ! pv_area_find_reg (stack, gdbarch, value.reg, 0));
1644 }
1645
1646
1647 /* Function for finding saved registers in a 'struct pv_area'; we pass
1648    this to pv_area_scan.
1649
1650    If VALUE is a saved register, ADDR says it was saved at a constant
1651    offset from the frame base, and SIZE indicates that the whole
1652    register was saved, record its offset in RESULT_UNTYPED.  */
1653 static void
1654 check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
1655 {
1656   struct mep_prologue *result = (struct mep_prologue *) result_untyped;
1657
1658   if (value.kind == pvk_register
1659       && value.k == 0
1660       && pv_is_register (addr, MEP_SP_REGNUM)
1661       && size == register_size (result->gdbarch, value.reg))
1662     result->reg_offset[value.reg] = addr.k;
1663 }
1664
1665
1666 /* Analyze a prologue starting at START_PC, going no further than
1667    LIMIT_PC.  Fill in RESULT as appropriate.  */
1668 static void
1669 mep_analyze_prologue (struct gdbarch *gdbarch,
1670                       CORE_ADDR start_pc, CORE_ADDR limit_pc,
1671                       struct mep_prologue *result)
1672 {
1673   CORE_ADDR pc;
1674   unsigned long insn;
1675   int rn;
1676   int found_lp = 0;
1677   pv_t reg[MEP_NUM_REGS];
1678   struct pv_area *stack;
1679   struct cleanup *back_to;
1680   CORE_ADDR after_last_frame_setup_insn = start_pc;
1681
1682   memset (result, 0, sizeof (*result));
1683   result->gdbarch = gdbarch;
1684
1685   for (rn = 0; rn < MEP_NUM_REGS; rn++)
1686     {
1687       reg[rn] = pv_register (rn, 0);
1688       result->reg_offset[rn] = 1;
1689     }
1690
1691   stack = make_pv_area (MEP_SP_REGNUM, gdbarch_addr_bit (gdbarch));
1692   back_to = make_cleanup_free_pv_area (stack);
1693
1694   pc = start_pc;
1695   while (pc < limit_pc)
1696     {
1697       CORE_ADDR next_pc;
1698       pv_t pre_insn_fp, pre_insn_sp;
1699
1700       next_pc = mep_get_insn (gdbarch, pc, &insn);
1701
1702       /* A zero return from mep_get_insn means that either we weren't
1703          able to read the instruction from memory, or that we don't
1704          have enough information to be able to reliably decode it.  So
1705          we'll store here and hope for the best.  */
1706       if (! next_pc)
1707         break;
1708
1709       /* Note the current values of the SP and FP, so we can tell if
1710          this instruction changed them, below.  */
1711       pre_insn_fp = reg[MEP_FP_REGNUM];
1712       pre_insn_sp = reg[MEP_SP_REGNUM];
1713
1714       if (IS_ADD (insn))
1715         {
1716           int rn = ADD_TARGET (insn);
1717           CORE_ADDR imm6 = ADD_OFFSET (insn);
1718
1719           reg[rn] = pv_add_constant (reg[rn], imm6);
1720         }
1721       else if (IS_ADD3_16 (insn))
1722         {
1723           int rn = ADD3_16_TARGET (insn);
1724           int imm7 = ADD3_16_OFFSET (insn);
1725
1726           reg[rn] = pv_add_constant (reg[MEP_SP_REGNUM], imm7);
1727         }
1728       else if (IS_ADD3_32 (insn))
1729         {
1730           int rn = ADD3_32_TARGET (insn);
1731           int rm = ADD3_32_SOURCE (insn);
1732           int imm16 = ADD3_32_OFFSET (insn);
1733
1734           reg[rn] = pv_add_constant (reg[rm], imm16);
1735         }
1736       else if (IS_SW_REG (insn))
1737         {
1738           int rn = SW_REG_SOURCE (insn);
1739           int rm = SW_REG_BASE (insn);
1740
1741           /* If simulating this store would require us to forget
1742              everything we know about the stack frame in the name of
1743              accuracy, it would be better to just quit now.  */
1744           if (pv_area_store_would_trash (stack, reg[rm]))
1745             break;
1746
1747           if (is_arg_spill (gdbarch, reg[rn], reg[rm], stack))
1748             after_last_frame_setup_insn = next_pc;
1749
1750           pv_area_store (stack, reg[rm], 4, reg[rn]);
1751         }
1752       else if (IS_SW_IMMD (insn))
1753         {
1754           int rn = SW_IMMD_SOURCE (insn);
1755           int offset = SW_IMMD_OFFSET (insn);
1756           pv_t addr = pv_add_constant (reg[MEP_SP_REGNUM], offset);
1757
1758           /* If simulating this store would require us to forget
1759              everything we know about the stack frame in the name of
1760              accuracy, it would be better to just quit now.  */
1761           if (pv_area_store_would_trash (stack, addr))
1762             break;
1763
1764           if (is_arg_spill (gdbarch, reg[rn], addr, stack))
1765             after_last_frame_setup_insn = next_pc;
1766
1767           pv_area_store (stack, addr, 4, reg[rn]);
1768         }
1769       else if (IS_MOV (insn))
1770         {
1771           int rn = MOV_TARGET (insn);
1772           int rm = MOV_SOURCE (insn);
1773
1774           reg[rn] = reg[rm];
1775
1776           if (pv_is_register (reg[rm], rm) && is_arg_reg (reg[rm]))
1777             after_last_frame_setup_insn = next_pc;
1778         }
1779       else if (IS_SB (insn) || IS_SH (insn) || IS_SW (insn))
1780         {
1781           int rn = SWBH_32_SOURCE (insn);
1782           int rm = SWBH_32_BASE (insn);
1783           int disp = SWBH_32_OFFSET (insn);
1784           int size = (IS_SB (insn) ? 1
1785                       : IS_SH (insn) ? 2
1786                       : (gdb_assert (IS_SW (insn)), 4));
1787           pv_t addr = pv_add_constant (reg[rm], disp);
1788
1789           if (pv_area_store_would_trash (stack, addr))
1790             break;
1791
1792           if (is_arg_spill (gdbarch, reg[rn], addr, stack))
1793             after_last_frame_setup_insn = next_pc;
1794
1795           pv_area_store (stack, addr, size, reg[rn]);
1796         }
1797       else if (IS_LDC (insn))
1798         {
1799           int rn = LDC_TARGET (insn);
1800           int cr = LDC_IMM (insn) + MEP_FIRST_CSR_REGNUM;
1801
1802           reg[rn] = reg[cr];
1803         }
1804       else if (IS_LW (insn))
1805         {
1806           int rn = LW_TARGET (insn);
1807           int rm = LW_BASE (insn);
1808           int offset = LW_OFFSET (insn);
1809           pv_t addr = pv_add_constant (reg[rm], offset);
1810
1811           reg[rn] = pv_area_fetch (stack, addr, 4);
1812         }
1813       else if (IS_BRA (insn) && BRA_DISP (insn) > 0)
1814         {
1815           /* When a loop appears as the first statement of a function
1816              body, gcc 4.x will use a BRA instruction to branch to the
1817              loop condition checking code.  This BRA instruction is
1818              marked as part of the prologue.  We therefore set next_pc
1819              to this branch target and also stop the prologue scan.
1820              The instructions at and beyond the branch target should
1821              no longer be associated with the prologue.
1822
1823              Note that we only consider forward branches here.  We
1824              presume that a forward branch is being used to skip over
1825              a loop body.
1826
1827              A backwards branch is covered by the default case below.
1828              If we were to encounter a backwards branch, that would
1829              most likely mean that we've scanned through a loop body.
1830              We definitely want to stop the prologue scan when this
1831              happens and that is precisely what is done by the default
1832              case below.  */
1833           next_pc = pc + BRA_DISP (insn);
1834           after_last_frame_setup_insn = next_pc;
1835           break;
1836         }
1837       else
1838         /* We've hit some instruction we don't know how to simulate.
1839            Strictly speaking, we should set every value we're
1840            tracking to "unknown".  But we'll be optimistic, assume
1841            that we have enough information already, and stop
1842            analysis here.  */
1843         break;
1844
1845       /* If this instruction changed the FP or decreased the SP (i.e.,
1846          allocated more stack space), then this may be a good place to
1847          declare the prologue finished.  However, there are some
1848          exceptions:
1849
1850          - If the instruction just changed the FP back to its original
1851            value, then that's probably a restore instruction.  The
1852            prologue should definitely end before that.
1853
1854          - If the instruction increased the value of the SP (that is,
1855            shrunk the frame), then it's probably part of a frame
1856            teardown sequence, and the prologue should end before that.  */
1857
1858       if (! pv_is_identical (reg[MEP_FP_REGNUM], pre_insn_fp))
1859         {
1860           if (! pv_is_register_k (reg[MEP_FP_REGNUM], MEP_FP_REGNUM, 0))
1861             after_last_frame_setup_insn = next_pc;
1862         }
1863       else if (! pv_is_identical (reg[MEP_SP_REGNUM], pre_insn_sp))
1864         {
1865           /* The comparison of constants looks odd, there, because .k
1866              is unsigned.  All it really means is that the new value
1867              is lower than it was before the instruction.  */
1868           if (pv_is_register (pre_insn_sp, MEP_SP_REGNUM)
1869               && pv_is_register (reg[MEP_SP_REGNUM], MEP_SP_REGNUM)
1870               && ((pre_insn_sp.k - reg[MEP_SP_REGNUM].k)
1871                   < (reg[MEP_SP_REGNUM].k - pre_insn_sp.k)))
1872             after_last_frame_setup_insn = next_pc;
1873         }
1874
1875       pc = next_pc;
1876     }
1877
1878   /* Is the frame size (offset, really) a known constant?  */
1879   if (pv_is_register (reg[MEP_SP_REGNUM], MEP_SP_REGNUM))
1880     result->frame_size = reg[MEP_SP_REGNUM].k;
1881
1882   /* Was the frame pointer initialized?  */
1883   if (pv_is_register (reg[MEP_FP_REGNUM], MEP_SP_REGNUM))
1884     {
1885       result->has_frame_ptr = 1;
1886       result->frame_ptr_offset = reg[MEP_FP_REGNUM].k;
1887     }
1888
1889   /* Record where all the registers were saved.  */
1890   pv_area_scan (stack, check_for_saved, (void *) result);
1891
1892   result->prologue_end = after_last_frame_setup_insn;
1893
1894   do_cleanups (back_to);
1895 }
1896
1897
1898 static CORE_ADDR
1899 mep_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1900 {
1901   const char *name;
1902   CORE_ADDR func_addr, func_end;
1903   struct mep_prologue p;
1904
1905   /* Try to find the extent of the function that contains PC.  */
1906   if (! find_pc_partial_function (pc, &name, &func_addr, &func_end))
1907     return pc;
1908
1909   mep_analyze_prologue (gdbarch, pc, func_end, &p);
1910   return p.prologue_end;
1911 }
1912
1913
1914 \f
1915 /* Breakpoints.  */
1916 constexpr gdb_byte mep_break_insn[] = { 0x70, 0x32 };
1917
1918 typedef BP_MANIPULATION (mep_break_insn) mep_breakpoint;
1919
1920 \f
1921 /* Frames and frame unwinding.  */
1922
1923
1924 static struct mep_prologue *
1925 mep_analyze_frame_prologue (struct frame_info *this_frame,
1926                             void **this_prologue_cache)
1927 {
1928   if (! *this_prologue_cache)
1929     {
1930       CORE_ADDR func_start, stop_addr;
1931
1932       *this_prologue_cache
1933         = FRAME_OBSTACK_ZALLOC (struct mep_prologue);
1934
1935       func_start = get_frame_func (this_frame);
1936       stop_addr = get_frame_pc (this_frame);
1937
1938       /* If we couldn't find any function containing the PC, then
1939          just initialize the prologue cache, but don't do anything.  */
1940       if (! func_start)
1941         stop_addr = func_start;
1942
1943       mep_analyze_prologue (get_frame_arch (this_frame),
1944                             func_start, stop_addr,
1945                             (struct mep_prologue *) *this_prologue_cache);
1946     }
1947
1948   return (struct mep_prologue *) *this_prologue_cache;
1949 }
1950
1951
1952 /* Given the next frame and a prologue cache, return this frame's
1953    base.  */
1954 static CORE_ADDR
1955 mep_frame_base (struct frame_info *this_frame,
1956                 void **this_prologue_cache)
1957 {
1958   struct mep_prologue *p
1959     = mep_analyze_frame_prologue (this_frame, this_prologue_cache);
1960
1961   /* In functions that use alloca, the distance between the stack
1962      pointer and the frame base varies dynamically, so we can't use
1963      the SP plus static information like prologue analysis to find the
1964      frame base.  However, such functions must have a frame pointer,
1965      to be able to restore the SP on exit.  So whenever we do have a
1966      frame pointer, use that to find the base.  */
1967   if (p->has_frame_ptr)
1968     {
1969       CORE_ADDR fp
1970         = get_frame_register_unsigned (this_frame, MEP_FP_REGNUM);
1971       return fp - p->frame_ptr_offset;
1972     }
1973   else
1974     {
1975       CORE_ADDR sp
1976         = get_frame_register_unsigned (this_frame, MEP_SP_REGNUM);
1977       return sp - p->frame_size;
1978     }
1979 }
1980
1981
1982 static void
1983 mep_frame_this_id (struct frame_info *this_frame,
1984                    void **this_prologue_cache,
1985                    struct frame_id *this_id)
1986 {
1987   *this_id = frame_id_build (mep_frame_base (this_frame, this_prologue_cache),
1988                              get_frame_func (this_frame));
1989 }
1990
1991
1992 static struct value *
1993 mep_frame_prev_register (struct frame_info *this_frame,
1994                          void **this_prologue_cache, int regnum)
1995 {
1996   struct mep_prologue *p
1997     = mep_analyze_frame_prologue (this_frame, this_prologue_cache);
1998
1999   /* There are a number of complications in unwinding registers on the
2000      MeP, having to do with core functions calling VLIW functions and
2001      vice versa.
2002
2003      The least significant bit of the link register, LP.LTOM, is the
2004      VLIW mode toggle bit: it's set if a core function called a VLIW
2005      function, or vice versa, and clear when the caller and callee
2006      were both in the same mode.
2007
2008      So, if we're asked to unwind the PC, then we really want to
2009      unwind the LP and clear the least significant bit.  (Real return
2010      addresses are always even.)  And if we want to unwind the program
2011      status word (PSW), we need to toggle PSW.OM if LP.LTOM is set.
2012
2013      Tweaking the register values we return in this way means that the
2014      bits in BUFFERP[] are not the same as the bits you'd find at
2015      ADDRP in the inferior, so we make sure lvalp is not_lval when we
2016      do this.  */
2017   if (regnum == MEP_PC_REGNUM)
2018     {
2019       struct value *value;
2020       CORE_ADDR lp;
2021       value = mep_frame_prev_register (this_frame, this_prologue_cache,
2022                                        MEP_LP_REGNUM);
2023       lp = value_as_long (value);
2024       release_value (value);
2025       value_free (value);
2026
2027       return frame_unwind_got_constant (this_frame, regnum, lp & ~1);
2028     }
2029   else
2030     {
2031       CORE_ADDR frame_base = mep_frame_base (this_frame, this_prologue_cache);
2032       struct value *value;
2033
2034       /* Our caller's SP is our frame base.  */
2035       if (regnum == MEP_SP_REGNUM)
2036         return frame_unwind_got_constant (this_frame, regnum, frame_base);
2037
2038       /* If prologue analysis says we saved this register somewhere,
2039          return a description of the stack slot holding it.  */
2040       if (p->reg_offset[regnum] != 1)
2041         value = frame_unwind_got_memory (this_frame, regnum,
2042                                          frame_base + p->reg_offset[regnum]);
2043
2044       /* Otherwise, presume we haven't changed the value of this
2045          register, and get it from the next frame.  */
2046       else
2047         value = frame_unwind_got_register (this_frame, regnum, regnum);
2048
2049       /* If we need to toggle the operating mode, do so.  */
2050       if (regnum == MEP_PSW_REGNUM)
2051         {
2052           CORE_ADDR psw, lp;
2053
2054           psw = value_as_long (value);
2055           release_value (value);
2056           value_free (value);
2057
2058           /* Get the LP's value, too.  */
2059           value = get_frame_register_value (this_frame, MEP_LP_REGNUM);
2060           lp = value_as_long (value);
2061           release_value (value);
2062           value_free (value);
2063
2064           /* If LP.LTOM is set, then toggle PSW.OM.  */
2065           if (lp & 0x1)
2066             psw ^= 0x1000;
2067
2068           return frame_unwind_got_constant (this_frame, regnum, psw);
2069         }
2070
2071       return value;
2072     }
2073 }
2074
2075
2076 static const struct frame_unwind mep_frame_unwind = {
2077   NORMAL_FRAME,
2078   default_frame_unwind_stop_reason,
2079   mep_frame_this_id,
2080   mep_frame_prev_register,
2081   NULL,
2082   default_frame_sniffer
2083 };
2084
2085
2086 /* Our general unwinding function can handle unwinding the PC.  */
2087 static CORE_ADDR
2088 mep_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2089 {
2090   return frame_unwind_register_unsigned (next_frame, MEP_PC_REGNUM);
2091 }
2092
2093
2094 /* Our general unwinding function can handle unwinding the SP.  */
2095 static CORE_ADDR
2096 mep_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2097 {
2098   return frame_unwind_register_unsigned (next_frame, MEP_SP_REGNUM);
2099 }
2100
2101
2102 \f
2103 /* Return values.  */
2104
2105
2106 static int
2107 mep_use_struct_convention (struct type *type)
2108 {
2109   return (TYPE_LENGTH (type) > MEP_GPR_SIZE);
2110 }
2111
2112
2113 static void
2114 mep_extract_return_value (struct gdbarch *arch,
2115                           struct type *type,
2116                           struct regcache *regcache,
2117                           gdb_byte *valbuf)
2118 {
2119   int byte_order = gdbarch_byte_order (arch);
2120
2121   /* Values that don't occupy a full register appear at the less
2122      significant end of the value.  This is the offset to where the
2123      value starts.  */
2124   int offset;
2125
2126   /* Return values > MEP_GPR_SIZE bytes are returned in memory,
2127      pointed to by R0.  */
2128   gdb_assert (TYPE_LENGTH (type) <= MEP_GPR_SIZE);
2129
2130   if (byte_order == BFD_ENDIAN_BIG)
2131     offset = MEP_GPR_SIZE - TYPE_LENGTH (type);
2132   else
2133     offset = 0;
2134
2135   /* Return values that do fit in a single register are returned in R0.  */
2136   regcache_cooked_read_part (regcache, MEP_R0_REGNUM,
2137                              offset, TYPE_LENGTH (type),
2138                              valbuf);
2139 }
2140
2141
2142 static void
2143 mep_store_return_value (struct gdbarch *arch,
2144                         struct type *type,
2145                         struct regcache *regcache,
2146                         const gdb_byte *valbuf)
2147 {
2148   int byte_order = gdbarch_byte_order (arch);
2149
2150   /* Values that fit in a single register go in R0.  */
2151   if (TYPE_LENGTH (type) <= MEP_GPR_SIZE)
2152     {
2153       /* Values that don't occupy a full register appear at the least
2154          significant end of the value.  This is the offset to where the
2155          value starts.  */
2156       int offset;
2157
2158       if (byte_order == BFD_ENDIAN_BIG)
2159         offset = MEP_GPR_SIZE - TYPE_LENGTH (type);
2160       else
2161         offset = 0;
2162
2163       regcache_cooked_write_part (regcache, MEP_R0_REGNUM,
2164                                   offset, TYPE_LENGTH (type),
2165                                   valbuf);
2166     }
2167
2168   /* Return values larger than a single register are returned in
2169      memory, pointed to by R0.  Unfortunately, we can't count on R0
2170      pointing to the return buffer, so we raise an error here.  */
2171   else
2172     error (_("\
2173 GDB cannot set return values larger than four bytes; the Media Processor's\n\
2174 calling conventions do not provide enough information to do this.\n\
2175 Try using the 'return' command with no argument."));
2176 }
2177
2178 static enum return_value_convention
2179 mep_return_value (struct gdbarch *gdbarch, struct value *function,
2180                   struct type *type, struct regcache *regcache,
2181                   gdb_byte *readbuf, const gdb_byte *writebuf)
2182 {
2183   if (mep_use_struct_convention (type))
2184     {
2185       if (readbuf)
2186         {
2187           ULONGEST addr;
2188           /* Although the address of the struct buffer gets passed in R1, it's
2189              returned in R0.  Fetch R0's value and then read the memory
2190              at that address.  */
2191           regcache_raw_read_unsigned (regcache, MEP_R0_REGNUM, &addr);
2192           read_memory (addr, readbuf, TYPE_LENGTH (type));
2193         }
2194       if (writebuf)
2195         {
2196           /* Return values larger than a single register are returned in
2197              memory, pointed to by R0.  Unfortunately, we can't count on R0
2198              pointing to the return buffer, so we raise an error here.  */
2199           error (_("\
2200 GDB cannot set return values larger than four bytes; the Media Processor's\n\
2201 calling conventions do not provide enough information to do this.\n\
2202 Try using the 'return' command with no argument."));
2203         }
2204       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
2205     }
2206
2207   if (readbuf)
2208     mep_extract_return_value (gdbarch, type, regcache, readbuf);
2209   if (writebuf)
2210     mep_store_return_value (gdbarch, type, regcache, writebuf);
2211
2212   return RETURN_VALUE_REGISTER_CONVENTION;
2213 }
2214
2215 \f
2216 /* Inferior calls.  */
2217
2218
2219 static CORE_ADDR
2220 mep_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
2221 {
2222   /* Require word alignment.  */
2223   return sp & -4;
2224 }
2225
2226
2227 /* From "lang_spec2.txt":
2228
2229    4.2 Calling conventions
2230
2231    4.2.1 Core register conventions
2232
2233    - Parameters should be evaluated from left to right, and they
2234      should be held in $1,$2,$3,$4 in order.  The fifth parameter or
2235      after should be held in the stack.  If the size is larger than 4
2236      bytes in the first four parameters, the pointer should be held in
2237      the registers instead.  If the size is larger than 4 bytes in the
2238      fifth parameter or after, the pointer should be held in the stack.
2239
2240    - Return value of a function should be held in register $0.  If the
2241      size of return value is larger than 4 bytes, $1 should hold the
2242      pointer pointing memory that would hold the return value.  In this
2243      case, the first parameter should be held in $2, the second one in
2244      $3, and the third one in $4, and the forth parameter or after
2245      should be held in the stack.
2246
2247    [This doesn't say so, but arguments shorter than four bytes are
2248    passed in the least significant end of a four-byte word when
2249    they're passed on the stack.]  */
2250
2251
2252 /* Traverse the list of ARGC arguments ARGV; for every ARGV[i] too
2253    large to fit in a register, save it on the stack, and place its
2254    address in COPY[i].  SP is the initial stack pointer; return the
2255    new stack pointer.  */
2256 static CORE_ADDR
2257 push_large_arguments (CORE_ADDR sp, int argc, struct value **argv,
2258                       CORE_ADDR copy[])
2259 {
2260   int i;
2261
2262   for (i = 0; i < argc; i++)
2263     {
2264       unsigned arg_len = TYPE_LENGTH (value_type (argv[i]));
2265
2266       if (arg_len > MEP_GPR_SIZE)
2267         {
2268           /* Reserve space for the copy, and then round the SP down, to
2269              make sure it's all aligned properly.  */
2270           sp = (sp - arg_len) & -4;
2271           write_memory (sp, value_contents (argv[i]), arg_len);
2272           copy[i] = sp;
2273         }
2274     }
2275
2276   return sp;
2277 }
2278
2279
2280 static CORE_ADDR
2281 mep_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
2282                      struct regcache *regcache, CORE_ADDR bp_addr,
2283                      int argc, struct value **argv, CORE_ADDR sp,
2284                      int struct_return,
2285                      CORE_ADDR struct_addr)
2286 {
2287   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2288   CORE_ADDR *copy = (CORE_ADDR *) alloca (argc * sizeof (copy[0]));
2289   CORE_ADDR func_addr = find_function_addr (function, NULL);
2290   int i;
2291
2292   /* The number of the next register available to hold an argument.  */
2293   int arg_reg;
2294
2295   /* The address of the next stack slot available to hold an argument.  */
2296   CORE_ADDR arg_stack;
2297
2298   /* The address of the end of the stack area for arguments.  This is
2299      just for error checking.  */
2300   CORE_ADDR arg_stack_end;
2301
2302   sp = push_large_arguments (sp, argc, argv, copy);
2303
2304   /* Reserve space for the stack arguments, if any.  */
2305   arg_stack_end = sp;
2306   if (argc + (struct_addr ? 1 : 0) > 4)
2307     sp -= ((argc + (struct_addr ? 1 : 0)) - 4) * MEP_GPR_SIZE;
2308
2309   arg_reg = MEP_R1_REGNUM;
2310   arg_stack = sp;
2311
2312   /* If we're returning a structure by value, push the pointer to the
2313      buffer as the first argument.  */
2314   if (struct_return)
2315     {
2316       regcache_cooked_write_unsigned (regcache, arg_reg, struct_addr);
2317       arg_reg++;
2318     }
2319
2320   for (i = 0; i < argc; i++)
2321     {
2322       ULONGEST value;
2323
2324       /* Arguments that fit in a GPR get expanded to fill the GPR.  */
2325       if (TYPE_LENGTH (value_type (argv[i])) <= MEP_GPR_SIZE)
2326         value = extract_unsigned_integer (value_contents (argv[i]),
2327                                           TYPE_LENGTH (value_type (argv[i])),
2328                                           byte_order);
2329
2330       /* Arguments too large to fit in a GPR get copied to the stack,
2331          and we pass a pointer to the copy.  */
2332       else
2333         value = copy[i];
2334
2335       /* We use $1 -- $4 for passing arguments, then use the stack.  */
2336       if (arg_reg <= MEP_R4_REGNUM)
2337         {
2338           regcache_cooked_write_unsigned (regcache, arg_reg, value);
2339           arg_reg++;
2340         }
2341       else
2342         {
2343           gdb_byte buf[MEP_GPR_SIZE];
2344           store_unsigned_integer (buf, MEP_GPR_SIZE, byte_order, value);
2345           write_memory (arg_stack, buf, MEP_GPR_SIZE);
2346           arg_stack += MEP_GPR_SIZE;
2347         }
2348     }
2349
2350   gdb_assert (arg_stack <= arg_stack_end);
2351
2352   /* Set the return address.  */
2353   regcache_cooked_write_unsigned (regcache, MEP_LP_REGNUM, bp_addr);
2354
2355   /* Update the stack pointer.  */
2356   regcache_cooked_write_unsigned (regcache, MEP_SP_REGNUM, sp);
2357
2358   return sp;
2359 }
2360
2361
2362 static struct frame_id
2363 mep_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2364 {
2365   CORE_ADDR sp = get_frame_register_unsigned (this_frame, MEP_SP_REGNUM);
2366   return frame_id_build (sp, get_frame_pc (this_frame));
2367 }
2368
2369
2370 \f
2371 /* Initialization.  */
2372
2373
2374 static struct gdbarch *
2375 mep_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2376 {
2377   struct gdbarch *gdbarch;
2378   struct gdbarch_tdep *tdep;
2379
2380   /* Which me_module are we building a gdbarch object for?  */
2381   CONFIG_ATTR me_module;
2382
2383   /* If we have a BFD in hand, figure out which me_module it was built
2384      for.  Otherwise, use the no-particular-me_module code.  */
2385   if (info.abfd)
2386     {
2387       /* The way to get the me_module code depends on the object file
2388          format.  At the moment, we only know how to handle ELF.  */
2389       if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
2390         {
2391           int flag = elf_elfheader (info.abfd)->e_flags & EF_MEP_INDEX_MASK;
2392           me_module = (CONFIG_ATTR) flag;
2393         }
2394       else
2395         me_module = CONFIG_NONE;
2396     }
2397   else
2398     me_module = CONFIG_NONE;
2399
2400   /* If we're setting the architecture from a file, check the
2401      endianness of the file against that of the me_module.  */
2402   if (info.abfd)
2403     {
2404       /* The negations on either side make the comparison treat all
2405          non-zero (true) values as equal.  */
2406       if (! bfd_big_endian (info.abfd) != ! me_module_big_endian (me_module))
2407         {
2408           const char *module_name = me_module_name (me_module);
2409           const char *module_endianness
2410             = me_module_big_endian (me_module) ? "big" : "little";
2411           const char *file_name = bfd_get_filename (info.abfd);
2412           const char *file_endianness
2413             = bfd_big_endian (info.abfd) ? "big" : "little";
2414
2415           fputc_unfiltered ('\n', gdb_stderr);
2416           if (module_name)
2417             warning (_("the MeP module '%s' is %s-endian, but the executable\n"
2418                        "%s is %s-endian."),
2419                      module_name, module_endianness,
2420                      file_name, file_endianness);
2421           else
2422             warning (_("the selected MeP module is %s-endian, but the "
2423                        "executable\n"
2424                        "%s is %s-endian."),
2425                      module_endianness, file_name, file_endianness);
2426         }
2427     }
2428
2429   /* Find a candidate among the list of architectures we've created
2430      already.  info->bfd_arch_info needs to match, but we also want
2431      the right me_module: the ELF header's e_flags field needs to
2432      match as well.  */
2433   for (arches = gdbarch_list_lookup_by_info (arches, &info);
2434        arches != NULL;
2435        arches = gdbarch_list_lookup_by_info (arches->next, &info))
2436     if (gdbarch_tdep (arches->gdbarch)->me_module == me_module)
2437       return arches->gdbarch;
2438
2439   tdep = XCNEW (struct gdbarch_tdep);
2440   gdbarch = gdbarch_alloc (&info, tdep);
2441
2442   /* Get a CGEN CPU descriptor for this architecture.  */
2443   {
2444     const char *mach_name = info.bfd_arch_info->printable_name;
2445     enum cgen_endian endian = (info.byte_order == BFD_ENDIAN_BIG
2446                                ? CGEN_ENDIAN_BIG
2447                                : CGEN_ENDIAN_LITTLE);
2448
2449     tdep->cpu_desc = mep_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
2450                                         CGEN_CPU_OPEN_ENDIAN, endian,
2451                                         CGEN_CPU_OPEN_END);
2452   }
2453
2454   tdep->me_module = me_module;
2455
2456   /* Register set.  */
2457   set_gdbarch_read_pc (gdbarch, mep_read_pc);
2458   set_gdbarch_num_regs (gdbarch, MEP_NUM_RAW_REGS);
2459   set_gdbarch_pc_regnum (gdbarch, MEP_PC_REGNUM);
2460   set_gdbarch_sp_regnum (gdbarch, MEP_SP_REGNUM);
2461   set_gdbarch_register_name (gdbarch, mep_register_name);
2462   set_gdbarch_register_type (gdbarch, mep_register_type);
2463   set_gdbarch_num_pseudo_regs (gdbarch, MEP_NUM_PSEUDO_REGS);
2464   set_gdbarch_pseudo_register_read (gdbarch, mep_pseudo_register_read);
2465   set_gdbarch_pseudo_register_write (gdbarch, mep_pseudo_register_write);
2466   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, mep_debug_reg_to_regnum);
2467   set_gdbarch_stab_reg_to_regnum (gdbarch, mep_debug_reg_to_regnum);
2468
2469   set_gdbarch_register_reggroup_p (gdbarch, mep_register_reggroup_p);
2470   reggroup_add (gdbarch, all_reggroup);
2471   reggroup_add (gdbarch, general_reggroup);
2472   reggroup_add (gdbarch, save_reggroup);
2473   reggroup_add (gdbarch, restore_reggroup);
2474   reggroup_add (gdbarch, mep_csr_reggroup);
2475   reggroup_add (gdbarch, mep_cr_reggroup);
2476   reggroup_add (gdbarch, mep_ccr_reggroup);
2477
2478   /* Disassembly.  */
2479   set_gdbarch_print_insn (gdbarch, mep_gdb_print_insn);
2480
2481   /* Breakpoints.  */
2482   set_gdbarch_breakpoint_kind_from_pc (gdbarch, mep_breakpoint::kind_from_pc);
2483   set_gdbarch_sw_breakpoint_from_kind (gdbarch, mep_breakpoint::bp_from_kind);
2484   set_gdbarch_decr_pc_after_break (gdbarch, 0);
2485   set_gdbarch_skip_prologue (gdbarch, mep_skip_prologue);
2486
2487   /* Frames and frame unwinding.  */
2488   frame_unwind_append_unwinder (gdbarch, &mep_frame_unwind);
2489   set_gdbarch_unwind_pc (gdbarch, mep_unwind_pc);
2490   set_gdbarch_unwind_sp (gdbarch, mep_unwind_sp);
2491   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2492   set_gdbarch_frame_args_skip (gdbarch, 0);
2493
2494   /* Return values.  */
2495   set_gdbarch_return_value (gdbarch, mep_return_value);
2496
2497   /* Inferior function calls.  */
2498   set_gdbarch_frame_align (gdbarch, mep_frame_align);
2499   set_gdbarch_push_dummy_call (gdbarch, mep_push_dummy_call);
2500   set_gdbarch_dummy_id (gdbarch, mep_dummy_id);
2501
2502   return gdbarch;
2503 }
2504
2505 void
2506 _initialize_mep_tdep (void)
2507 {
2508   mep_csr_reggroup = reggroup_new ("csr", USER_REGGROUP);
2509   mep_cr_reggroup  = reggroup_new ("cr", USER_REGGROUP);
2510   mep_ccr_reggroup = reggroup_new ("ccr", USER_REGGROUP);
2511
2512   register_gdbarch_init (bfd_arch_mep, mep_gdbarch_init);
2513
2514   mep_init_pseudoregister_maps ();
2515 }