gdb/lm32-tdep.c

   1 /* Target-dependent code for Lattice Mico32 processor, for GDB.
   2    Contributed by Jon Beniston <jon@beniston.com>
   3
   4    Copyright (C) 2009 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "frame-unwind.h"
  24 #include "frame-base.h"
  25 #include "inferior.h"
  26 #include "dis-asm.h"
  27 #include "symfile.h"
  28 #include "remote.h"
  29 #include "gdbcore.h"
  30 #include "gdb/sim-lm32.h"
  31 #include "gdb/callback.h"
  32 #include "gdb/remote-sim.h"
  33 #include "sim-regno.h"
  34 #include "arch-utils.h"
  35 #include "regcache.h"
  36 #include "trad-frame.h"
  37 #include "reggroups.h"
  38 #include "opcodes/lm32-desc.h"
  39
  40 #include "gdb_string.h"
  41
  42 /* Macros to extract fields from an instruction.  */
  43 #define LM32_OPCODE(insn)       ((insn >> 26) & 0x3f)
  44 #define LM32_REG0(insn)         ((insn >> 21) & 0x1f)
  45 #define LM32_REG1(insn)         ((insn >> 16) & 0x1f)
  46 #define LM32_REG2(insn)         ((insn >> 11) & 0x1f)
  47 #define LM32_IMM16(insn)        ((((long)insn & 0xffff) << 16) >> 16)
  48
  49 struct gdbarch_tdep
  50 {
  51   /* gdbarch target dependent data here. Currently unused for LM32.  */
  52 };
  53
  54 struct lm32_frame_cache
  55 {
  56   /* The frame's base.  Used when constructing a frame ID.  */
  57   CORE_ADDR base;
  58   CORE_ADDR pc;
  59   /* Size of frame.  */
  60   int size;
  61   /* Table indicating the location of each and every register.  */
  62   struct trad_frame_saved_reg *saved_regs;
  63 };
  64
  65 /* Add the available register groups.  */
  66
  67 static void
  68 lm32_add_reggroups (struct gdbarch *gdbarch)
  69 {
  70   reggroup_add (gdbarch, general_reggroup);
  71   reggroup_add (gdbarch, all_reggroup);
  72   reggroup_add (gdbarch, system_reggroup);
  73 }
  74
  75 /* Return whether a given register is in a given group.  */
  76
  77 static int
  78 lm32_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
  79                           struct reggroup *group)
  80 {
  81   if (group == general_reggroup)
  82     return ((regnum >= SIM_LM32_R0_REGNUM) && (regnum <= SIM_LM32_RA_REGNUM))
  83       || (regnum == SIM_LM32_PC_REGNUM);
  84   else if (group == system_reggroup)
  85     return ((regnum >= SIM_LM32_EA_REGNUM) && (regnum <= SIM_LM32_BA_REGNUM))
  86       || ((regnum >= SIM_LM32_EID_REGNUM) && (regnum <= SIM_LM32_IP_REGNUM));
  87   return default_register_reggroup_p (gdbarch, regnum, group);
  88 }
  89
  90 /* Return a name that corresponds to the given register number.  */
  91
  92 static const char *
  93 lm32_register_name (struct gdbarch *gdbarch, int reg_nr)
  94 {
  95   static char *register_names[] = {
  96     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  97     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
  98     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
  99     "r24", "r25", "gp", "fp", "sp", "ra", "ea", "ba",
 100     "PC", "EID", "EBA", "DEBA", "IE", "IM", "IP"
 101   };
 102
 103   if ((reg_nr < 0) || (reg_nr >= ARRAY_SIZE (register_names)))
 104     return NULL;
 105   else
 106     return register_names[reg_nr];
 107 }
 108
 109 /* Return type of register.  */
 110
 111 static struct type *
 112 lm32_register_type (struct gdbarch *gdbarch, int reg_nr)
 113 {
 114   return builtin_type_int32;
 115 }
 116
 117 /* Return non-zero if a register can't be written.  */
 118
 119 static int
 120 lm32_cannot_store_register (struct gdbarch *gdbarch, int regno)
 121 {
 122   return (regno == SIM_LM32_R0_REGNUM) || (regno == SIM_LM32_EID_REGNUM);
 123 }
 124
 125 /* Analyze a function's prologue.  */
 126
 127 static CORE_ADDR
 128 lm32_analyze_prologue (CORE_ADDR pc, CORE_ADDR limit,
 129                        struct lm32_frame_cache *info)
 130 {
 131   unsigned long instruction;
 132
 133   /* Keep reading though instructions, until we come across an instruction
 134      that isn't likely to be part of the prologue.  */
 135   info->size = 0;
 136   for (; pc < limit; pc += 4)
 137     {
 138
 139       /* Read an instruction.  */
 140       instruction = read_memory_integer (pc, 4);
 141
 142       if ((LM32_OPCODE (instruction) == OP_SW)
 143           && (LM32_REG0 (instruction) == SIM_LM32_SP_REGNUM))
 144         {
 145           /* Any stack displaced store is likely part of the prologue.
 146              Record that the register is being saved, and the offset
 147              into the stack.  */
 148           info->saved_regs[LM32_REG1 (instruction)].addr =
 149             LM32_IMM16 (instruction);
 150         }
 151       else if ((LM32_OPCODE (instruction) == OP_ADDI)
 152                && (LM32_REG1 (instruction) == SIM_LM32_SP_REGNUM))
 153         {
 154           /* An add to the SP is likely to be part of the prologue.
 155              Adjust stack size by whatever the instruction adds to the sp.  */
 156           info->size -= LM32_IMM16 (instruction);
 157         }
 158       else if (                 /* add fp,fp,sp */
 159                 ((LM32_OPCODE (instruction) == OP_ADD)
 160                  && (LM32_REG2 (instruction) == SIM_LM32_FP_REGNUM)
 161                  && (LM32_REG0 (instruction) == SIM_LM32_FP_REGNUM)
 162                  && (LM32_REG1 (instruction) == SIM_LM32_SP_REGNUM))
 163                 /* mv fp,imm */
 164                 || ((LM32_OPCODE (instruction) == OP_ADDI)
 165                     && (LM32_REG1 (instruction) == SIM_LM32_FP_REGNUM)
 166                     && (LM32_REG0 (instruction) == SIM_LM32_R0_REGNUM)))
 167         {
 168           /* Likely to be in the prologue for functions that require
 169              a frame pointer.  */
 170         }
 171       else
 172         {
 173           /* Any other instruction is likely not to be part of the prologue.  */
 174           break;
 175         }
 176     }
 177
 178   return pc;
 179 }
 180
 181 /* Return PC of first non prologue instruction, for the function at the
 182    specified address.  */
 183
 184 static CORE_ADDR
 185 lm32_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 186 {
 187   CORE_ADDR func_addr, limit_pc;
 188   struct symtab_and_line sal;
 189   struct lm32_frame_cache frame_info;
 190   struct trad_frame_saved_reg saved_regs[SIM_LM32_NUM_REGS];
 191
 192   /* See if we can determine the end of the prologue via the symbol table.
 193      If so, then return either PC, or the PC after the prologue, whichever
 194      is greater.  */
 195   if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
 196     {
 197       CORE_ADDR post_prologue_pc
 198         = skip_prologue_using_sal (gdbarch, func_addr);
 199       if (post_prologue_pc != 0)
 200         return max (pc, post_prologue_pc);
 201     }
 202
 203   /* Can't determine prologue from the symbol table, need to examine
 204      instructions.  */
 205
 206   /* Find an upper limit on the function prologue using the debug
 207      information.  If the debug information could not be used to provide
 208      that bound, then use an arbitrary large number as the upper bound.  */
 209   limit_pc = skip_prologue_using_sal (gdbarch, pc);
 210   if (limit_pc == 0)
 211     limit_pc = pc + 100;        /* Magic.  */
 212
 213   frame_info.saved_regs = saved_regs;
 214   return lm32_analyze_prologue (pc, limit_pc, &frame_info);
 215 }
 216
 217 /* Create a breakpoint instruction.  */
 218
 219 static const gdb_byte *
 220 lm32_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 221                          int *lenptr)
 222 {
 223   static const gdb_byte breakpoint[4] = { OP_RAISE << 2, 0, 0, 2 };
 224
 225   *lenptr = sizeof (breakpoint);
 226   return breakpoint;
 227 }
 228
 229 /* Setup registers and stack for faking a call to a function in the
 230    inferior.  */
 231
 232 static CORE_ADDR
 233 lm32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 234                       struct regcache *regcache, CORE_ADDR bp_addr,
 235                       int nargs, struct value **args, CORE_ADDR sp,
 236                       int struct_return, CORE_ADDR struct_addr)
 237 {
 238   int first_arg_reg = SIM_LM32_R1_REGNUM;
 239   int num_arg_regs = 8;
 240   int i;
 241
 242   /* Set the return address.  */
 243   regcache_cooked_write_signed (regcache, SIM_LM32_RA_REGNUM, bp_addr);
 244
 245   /* If we're returning a large struct, a pointer to the address to
 246      store it at is passed as a first hidden parameter.  */
 247   if (struct_return)
 248     {
 249       regcache_cooked_write_unsigned (regcache, first_arg_reg, struct_addr);
 250       first_arg_reg++;
 251       num_arg_regs--;
 252       sp -= 4;
 253     }
 254
 255   /* Setup parameters.  */
 256   for (i = 0; i < nargs; i++)
 257     {
 258       struct value *arg = args[i];
 259       struct type *arg_type = check_typedef (value_type (arg));
 260       gdb_byte *contents;
 261       int len;
 262       int j;
 263       int reg;
 264       ULONGEST val;
 265
 266       /* Promote small integer types to int.  */
 267       switch (TYPE_CODE (arg_type))
 268         {
 269         case TYPE_CODE_INT:
 270         case TYPE_CODE_BOOL:
 271         case TYPE_CODE_CHAR:
 272         case TYPE_CODE_RANGE:
 273         case TYPE_CODE_ENUM:
 274           if (TYPE_LENGTH (arg_type) < 4)
 275             {
 276               arg_type = builtin_type_int32;
 277               arg = value_cast (arg_type, arg);
 278             }
 279           break;
 280         }
 281
 282       /* FIXME: Handle structures.  */
 283
 284       contents = (gdb_byte *) value_contents (arg);
 285       len = TYPE_LENGTH (arg_type);
 286       val = extract_unsigned_integer (contents, len);
 287
 288       /* First num_arg_regs parameters are passed by registers,
 289          and the rest are passed on the stack.  */
 290       if (i < num_arg_regs)
 291         regcache_cooked_write_unsigned (regcache, first_arg_reg + i, val);
 292       else
 293         {
 294           write_memory (sp, (void *) &val, len);
 295           sp -= 4;
 296         }
 297     }
 298
 299   /* Update stack pointer.  */
 300   regcache_cooked_write_signed (regcache, SIM_LM32_SP_REGNUM, sp);
 301
 302   /* Return adjusted stack pointer.  */
 303   return sp;
 304 }
 305
 306 /* Extract return value after calling a function in the inferior.  */
 307
 308 static void
 309 lm32_extract_return_value (struct type *type, struct regcache *regcache,
 310                            gdb_byte *valbuf)
 311 {
 312   int offset;
 313   ULONGEST l;
 314   CORE_ADDR return_buffer;
 315
 316   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 317       && TYPE_CODE (type) != TYPE_CODE_UNION
 318       && TYPE_CODE (type) != TYPE_CODE_ARRAY && TYPE_LENGTH (type) <= 4)
 319     {
 320       /* Return value is returned in a single register.  */
 321       regcache_cooked_read_unsigned (regcache, SIM_LM32_R1_REGNUM, &l);
 322       store_unsigned_integer (valbuf, TYPE_LENGTH (type), l);
 323     }
 324   else if ((TYPE_CODE (type) == TYPE_CODE_INT) && (TYPE_LENGTH (type) == 8))
 325     {
 326       /* 64-bit values are returned in a register pair.  */
 327       regcache_cooked_read_unsigned (regcache, SIM_LM32_R1_REGNUM, &l);
 328       memcpy (valbuf, &l, 4);
 329       regcache_cooked_read_unsigned (regcache, SIM_LM32_R2_REGNUM, &l);
 330       memcpy (valbuf + 4, &l, 4);
 331     }
 332   else
 333     {
 334       /* Aggregate types greater than a single register are returned in memory.
 335          FIXME: Unless they are only 2 regs?.  */
 336       regcache_cooked_read_unsigned (regcache, SIM_LM32_R1_REGNUM, &l);
 337       return_buffer = l;
 338       read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
 339     }
 340 }
 341
 342 /* Write into appropriate registers a function return value of type
 343    TYPE, given in virtual format.  */
 344 static void
 345 lm32_store_return_value (struct type *type, struct regcache *regcache,
 346                          const gdb_byte *valbuf)
 347 {
 348   ULONGEST val;
 349   int len = TYPE_LENGTH (type);
 350
 351   if (len <= 4)
 352     {
 353       val = extract_unsigned_integer (valbuf, len);
 354       regcache_cooked_write_unsigned (regcache, SIM_LM32_R1_REGNUM, val);
 355     }
 356   else if (len <= 8)
 357     {
 358       val = extract_unsigned_integer (valbuf, 4);
 359       regcache_cooked_write_unsigned (regcache, SIM_LM32_R1_REGNUM, val);
 360       val = extract_unsigned_integer (valbuf + 4, len - 4);
 361       regcache_cooked_write_unsigned (regcache, SIM_LM32_R2_REGNUM, val);
 362     }
 363   else
 364     error (_("lm32_store_return_value: type length too large."));
 365 }
 366
 367 /* Determine whether a functions return value is in a register or memory.  */
 368 static enum return_value_convention
 369 lm32_return_value (struct gdbarch *gdbarch, struct type *func_type,
 370                    struct type *valtype, struct regcache *regcache,
 371                    gdb_byte *readbuf, const gdb_byte *writebuf)
 372 {
 373   enum type_code code = TYPE_CODE (valtype);
 374
 375   if (code == TYPE_CODE_STRUCT
 376       || code == TYPE_CODE_UNION
 377       || code == TYPE_CODE_ARRAY || TYPE_LENGTH (valtype) > 8)
 378     return RETURN_VALUE_STRUCT_CONVENTION;
 379
 380   if (readbuf)
 381     lm32_extract_return_value (valtype, regcache, readbuf);
 382   if (writebuf)
 383     lm32_store_return_value (valtype, regcache, writebuf);
 384
 385   return RETURN_VALUE_REGISTER_CONVENTION;
 386 }
 387
 388 static CORE_ADDR
 389 lm32_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 390 {
 391   return frame_unwind_register_unsigned (next_frame, SIM_LM32_PC_REGNUM);
 392 }
 393
 394 static CORE_ADDR
 395 lm32_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 396 {
 397   return frame_unwind_register_unsigned (next_frame, SIM_LM32_SP_REGNUM);
 398 }
 399
 400 static struct frame_id
 401 lm32_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 402 {
 403   CORE_ADDR sp = get_frame_register_unsigned (this_frame, SIM_LM32_SP_REGNUM);
 404
 405   return frame_id_build (sp, get_frame_pc (this_frame));
 406 }
 407
 408 /* Put here the code to store, into fi->saved_regs, the addresses of
 409    the saved registers of frame described by FRAME_INFO.  This
 410    includes special registers such as pc and fp saved in special ways
 411    in the stack frame.  sp is even more special: the address we return
 412    for it IS the sp for the next frame.  */
 413
 414 static struct lm32_frame_cache *
 415 lm32_frame_cache (struct frame_info *this_frame, void **this_prologue_cache)
 416 {
 417   CORE_ADDR prologue_pc;
 418   CORE_ADDR current_pc;
 419   ULONGEST prev_sp;
 420   ULONGEST this_base;
 421   struct lm32_frame_cache *info;
 422   int prefixed;
 423   unsigned long instruction;
 424   int op;
 425   int offsets[32];
 426   int i;
 427   long immediate;
 428
 429   if ((*this_prologue_cache))
 430     return (*this_prologue_cache);
 431
 432   info = FRAME_OBSTACK_ZALLOC (struct lm32_frame_cache);
 433   (*this_prologue_cache) = info;
 434   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 435
 436   info->pc = get_frame_func (this_frame);
 437   current_pc = get_frame_pc (this_frame);
 438   lm32_analyze_prologue (info->pc, current_pc, info);
 439
 440   /* Compute the frame's base, and the previous frame's SP.  */
 441   this_base = get_frame_register_unsigned (this_frame, SIM_LM32_SP_REGNUM);
 442   prev_sp = this_base + info->size;
 443   info->base = this_base;
 444
 445   /* Convert callee save offsets into addresses.  */
 446   for (i = 0; i < gdbarch_num_regs (get_frame_arch (this_frame)) - 1; i++)
 447     {
 448       if (trad_frame_addr_p (info->saved_regs, i))
 449         info->saved_regs[i].addr = this_base + info->saved_regs[i].addr;
 450     }
 451
 452   /* The call instruction moves the caller's PC in the callee's RA register.
 453      Since this is an unwind, do the reverse.  Copy the location of RA register
 454      into PC (the address / regnum) so that a request for PC will be
 455      converted into a request for the RA register.  */
 456   info->saved_regs[SIM_LM32_PC_REGNUM] = info->saved_regs[SIM_LM32_RA_REGNUM];
 457
 458   /* The previous frame's SP needed to be computed.  Save the computed value. */
 459   trad_frame_set_value (info->saved_regs, SIM_LM32_SP_REGNUM, prev_sp);
 460
 461   return info;
 462 }
 463
 464 static void
 465 lm32_frame_this_id (struct frame_info *this_frame, void **this_cache,
 466                     struct frame_id *this_id)
 467 {
 468   struct lm32_frame_cache *cache = lm32_frame_cache (this_frame, this_cache);
 469
 470   /* This marks the outermost frame.  */
 471   if (cache->base == 0)
 472     return;
 473
 474   (*this_id) = frame_id_build (cache->base, cache->pc);
 475 }
 476
 477 static struct value *
 478 lm32_frame_prev_register (struct frame_info *this_frame,
 479                           void **this_prologue_cache, int regnum)
 480 {
 481   struct lm32_frame_cache *info;
 482
 483   info = lm32_frame_cache (this_frame, this_prologue_cache);
 484   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
 485 }
 486
 487 static const struct frame_unwind lm32_frame_unwind = {
 488   NORMAL_FRAME,
 489   lm32_frame_this_id,
 490   lm32_frame_prev_register,
 491   NULL,
 492   default_frame_sniffer
 493 };
 494
 495 static CORE_ADDR
 496 lm32_frame_base_address (struct frame_info *this_frame, void **this_cache)
 497 {
 498   struct lm32_frame_cache *info = lm32_frame_cache (this_frame, this_cache);
 499
 500   return info->base;
 501 }
 502
 503 static const struct frame_base lm32_frame_base = {
 504   &lm32_frame_unwind,
 505   lm32_frame_base_address,
 506   lm32_frame_base_address,
 507   lm32_frame_base_address
 508 };
 509
 510 static CORE_ADDR
 511 lm32_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
 512 {
 513   /* Align to the size of an instruction (so that they can safely be
 514      pushed onto the stack.  */
 515   return sp & ~3;
 516 }
 517
 518 static struct gdbarch *
 519 lm32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 520 {
 521   struct gdbarch *gdbarch;
 522   struct gdbarch_tdep *tdep;
 523
 524   /* If there is already a candidate, use it.  */
 525   arches = gdbarch_list_lookup_by_info (arches, &info);
 526   if (arches != NULL)
 527     return arches->gdbarch;
 528
 529   /* None found, create a new architecture from the information provided.  */
 530   tdep = XMALLOC (struct gdbarch_tdep);
 531   gdbarch = gdbarch_alloc (&info, tdep);
 532
 533   /* Type sizes.  */
 534   set_gdbarch_short_bit (gdbarch, 16);
 535   set_gdbarch_int_bit (gdbarch, 32);
 536   set_gdbarch_long_bit (gdbarch, 32);
 537   set_gdbarch_long_long_bit (gdbarch, 64);
 538   set_gdbarch_float_bit (gdbarch, 32);
 539   set_gdbarch_double_bit (gdbarch, 64);
 540   set_gdbarch_long_double_bit (gdbarch, 64);
 541   set_gdbarch_ptr_bit (gdbarch, 32);
 542
 543   /* Register info.  */
 544   set_gdbarch_num_regs (gdbarch, SIM_LM32_NUM_REGS);
 545   set_gdbarch_sp_regnum (gdbarch, SIM_LM32_SP_REGNUM);
 546   set_gdbarch_pc_regnum (gdbarch, SIM_LM32_PC_REGNUM);
 547   set_gdbarch_register_name (gdbarch, lm32_register_name);
 548   set_gdbarch_register_type (gdbarch, lm32_register_type);
 549   set_gdbarch_cannot_store_register (gdbarch, lm32_cannot_store_register);
 550
 551   /* Frame info.  */
 552   set_gdbarch_skip_prologue (gdbarch, lm32_skip_prologue);
 553   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 554   set_gdbarch_decr_pc_after_break (gdbarch, 0);
 555   set_gdbarch_frame_args_skip (gdbarch, 0);
 556
 557   /* Frame unwinding.  */
 558   set_gdbarch_frame_align (gdbarch, lm32_frame_align);
 559   frame_base_set_default (gdbarch, &lm32_frame_base);
 560   set_gdbarch_unwind_pc (gdbarch, lm32_unwind_pc);
 561   set_gdbarch_unwind_sp (gdbarch, lm32_unwind_sp);
 562   set_gdbarch_dummy_id (gdbarch, lm32_dummy_id);
 563   frame_unwind_append_unwinder (gdbarch, &lm32_frame_unwind);
 564
 565   /* Breakpoints.  */
 566   set_gdbarch_breakpoint_from_pc (gdbarch, lm32_breakpoint_from_pc);
 567   set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
 568
 569   /* Calling functions in the inferior.  */
 570   set_gdbarch_push_dummy_call (gdbarch, lm32_push_dummy_call);
 571   set_gdbarch_return_value (gdbarch, lm32_return_value);
 572
 573   /* Instruction disassembler.  */
 574   set_gdbarch_print_insn (gdbarch, print_insn_lm32);
 575
 576   lm32_add_reggroups (gdbarch);
 577   set_gdbarch_register_reggroup_p (gdbarch, lm32_register_reggroup_p);
 578
 579   return gdbarch;
 580 }
 581
 582 void
 583 _initialize_lm32_tdep (void)
 584 {
 585   register_gdbarch_init (bfd_arch_lm32, lm32_gdbarch_init);
 586 }