Merge GDB 7.5.1

gdb/tic6x-tdep.c

 /* Target dependent code for GDB on TI C6x systems.
 
    Copyright (C) 2010-2012 Free Software Foundation, Inc.
    Contributed by Andrew Jenner <andrew@codesourcery.com>
    Contributed by Yao Qi <yao@codesourcery.com>
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ skipping 128 matching lines @@
     cache->reg_saved[i] = -1;
 }
 
 static unsigned long tic6x_fetch_instruction (struct gdbarch *, CORE_ADDR);
 static int tic6x_register_number (int reg, int side, int crosspath);
 
 /* Do a full analysis of the prologue at START_PC and update CACHE accordingly.
    Bail out early if CURRENT_PC is reached.  Returns the address of the first
    instruction after the prologue.  */
 
-CORE_ADDR
+static CORE_ADDR
 tic6x_analyze_prologue (struct gdbarch *gdbarch, const CORE_ADDR start_pc,
                         const CORE_ADDR current_pc,
                         struct tic6x_unwind_cache *cache,
                         struct frame_info *this_frame)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   unsigned long inst;
   unsigned int src_reg, base_reg, dst_reg;
   int i;
   CORE_ADDR pc = start_pc;
@@ skipping 131 matching lines @@
      instead of offsets.  */
   for (i = 0; i < TIC6X_NUM_CORE_REGS; i++)
     if (cache->reg_saved[i] != -1)
       cache->reg_saved[i] = cache->base + cache->reg_saved[i];
 
   return return_pc;
 }
 
 /* This is the implementation of gdbarch method skip_prologue.  */
 
-CORE_ADDR
+static CORE_ADDR
 tic6x_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
 {
-  CORE_ADDR limit_pc;
   CORE_ADDR func_addr;
   struct tic6x_unwind_cache cache;
 
   /* See if we can determine the end of the prologue via the symbol table.
      If so, then return either PC, or the PC after the prologue, whichever is
      greater.  */
   if (find_pc_partial_function (start_pc, NULL, &func_addr, NULL))
     {
       CORE_ADDR post_prologue_pc
         = skip_prologue_using_sal (gdbarch, func_addr);
       if (post_prologue_pc != 0)
         return max (start_pc, post_prologue_pc);
     }
 
   /* Can't determine prologue from the symbol table, need to examine
      instructions.  */
   return tic6x_analyze_prologue (gdbarch, start_pc, (CORE_ADDR) -1, &cache,
                                  NULL);
 }
 
 /* This is the implementation of gdbarch method breakpiont_from_pc.  */
 
-const unsigned char*
+static const unsigned char*
 tic6x_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *bp_addr,
                           int *bp_size)
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   *bp_size = 4;
 
   if (tdep == NULL || tdep->breakpoint == NULL)
     {
       if (BFD_ENDIAN_BIG == gdbarch_byte_order_for_code (gdbarch))
@@ skipping 53 matching lines @@
 
 static CORE_ADDR
 tic6x_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
 {
   return frame_unwind_register_unsigned (this_frame, TIC6X_SP_REGNUM);
 }
 
 
 /* Frame base handling.  */
 
-struct tic6x_unwind_cache*
+static struct tic6x_unwind_cache*
 tic6x_frame_unwind_cache (struct frame_info *this_frame,
                           void **this_prologue_cache)
 {
   struct gdbarch *gdbarch = get_frame_arch (this_frame);
   CORE_ADDR current_pc;
   struct tic6x_unwind_cache *cache;
-  int i;
 
   if (*this_prologue_cache)
     return *this_prologue_cache;
 
   cache = FRAME_OBSTACK_ZALLOC (struct tic6x_unwind_cache);
   (*this_prologue_cache) = cache;
 
   cache->return_regnum = TIC6X_RA_REGNUM;
 
   tic6x_setup_default (cache);
@@ skipping 180 matching lines @@
   return r;
 }
 
 /* Determine where to set a single step breakpoint.  */
 
 static CORE_ADDR
 tic6x_get_next_pc (struct frame_info *frame, CORE_ADDR pc)
 {
   struct gdbarch *gdbarch = get_frame_arch (frame);
   unsigned long inst;
-  int offset;
   int register_number;
   int last = 0;
 
   do
     {
       inst = tic6x_fetch_instruction (gdbarch, pc);
 
       last = !(inst & 1);
 
       if (inst == TIC6X_INST_SWE)
@@ skipping 71 matching lines @@
             }
         }
       pc += TIC6X_OPCODE_SIZE;
     }
   while (!last);
   return pc;
 }
 
 /* This is the implementation of gdbarch method software_single_step.  */
 
-int
+static int
 tic6x_software_single_step (struct frame_info *frame)
 {
   struct gdbarch *gdbarch = get_frame_arch (frame);
   struct address_space *aspace = get_frame_address_space (frame);
   CORE_ADDR next_pc = tic6x_get_next_pc (frame, get_frame_pc (frame));
 
   insert_single_step_breakpoint (gdbarch, aspace, next_pc);
 
   return 1;
 }
@@ skipping 102 matching lines @@
         {
           regcache_cooked_write (regcache, TIC6X_A4_REGNUM, valbuf);
           regcache_cooked_write (regcache, TIC6X_A5_REGNUM, valbuf + 4);
         }
     }
 }
 
 /* This is the implementation of gdbarch method return_value.  */
 
 static enum return_value_convention
-tic6x_return_value (struct gdbarch *gdbarch, struct type *func_type,
+tic6x_return_value (struct gdbarch *gdbarch, struct value *function,
                     struct type *type, struct regcache *regcache,
                     gdb_byte *readbuf, const gdb_byte *writebuf)
 {
+  /* In C++, when function returns an object, even its size is small
+     enough, it stii has to be passed via reference, pointed by register
+     A3.  */
+  if (current_language->la_language == language_cplus)
+    {
+      if (type != NULL)
+        {
+          CHECK_TYPEDEF (type);
+          if (language_pass_by_reference (type))
+            return RETURN_VALUE_STRUCT_CONVENTION;
+        }
+    }
+
   if (TYPE_LENGTH (type) > 8)
     return RETURN_VALUE_STRUCT_CONVENTION;
 
   if (readbuf)
     tic6x_extract_return_value (type, regcache,
                                 gdbarch_byte_order (gdbarch), readbuf);
   if (writebuf)
     tic6x_store_return_value (type, regcache,
                               gdbarch_byte_order (gdbarch), writebuf);
 
@@ skipping 70 matching lines @@
   int argnum;
   int len = 0;
   int stack_offset = 4;
   int references_offset = 4;
   CORE_ADDR func_addr = find_function_addr (function, NULL);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   struct type *func_type = value_type (function);
   /* The first arg passed on stack.  Mostly the first 10 args are passed by
      registers.  */
   int first_arg_on_stack = 10;
-  /* If this inf-call is a cpp method call, and return value is passed by
-     reference, this flag is set to 1, otherwise set to 0.  We need this flag
-     because computation of the return location in
-     infcall.c:call_function_by_hand is wrong for C6000 ELF ABI.  In
-     call_function_by_hand, the language is considered first, and then
-     target ABI is considered.  If language_pass_by_reference returns true,
-     the return location is passed as the first parameter to the function,
-     which is conflict with C6000 ELF ABI.  If this flag is true, we should
-     adjust args and return locations accordingly to comply with C6000 ELF
-     ABI.  */
-  int cplus_return_struct_by_reference = 0;
 
-  if (current_language->la_language == language_cplus)
-    {
-      struct type *values_type;
-
-      find_function_addr (function, &values_type);
-
-      if (values_type)
-        {
-          CHECK_TYPEDEF (values_type);
-          if (language_pass_by_reference (values_type))
-            cplus_return_struct_by_reference = 1;
-        }
-
-    }
   /* Set the return address register to point to the entry point of
      the program, where a breakpoint lies in wait.  */
   regcache_cooked_write_unsigned (regcache, TIC6X_RA_REGNUM, bp_addr);
 
   /* The caller must pass an argument in A3 containing a destination address
      for the returned value.  The callee returns the object by copying it to
      the address in A3.  */
   if (struct_return)
     regcache_cooked_write_unsigned (regcache, 3, struct_addr);
-  else if (cplus_return_struct_by_reference)
-    /* When cplus_return_struct_by_reference is 1, means local variable
-       lang_struct_return in call_function_by_hand is 1, so struct is
-       returned by reference, even STRUCT_RETURN is 0.  Note that STRUCT_ADDR
-       is still valid in this case.  */
-    regcache_cooked_write_unsigned (regcache, 3, struct_addr);
 
   /* Determine the type of this function.  */
   func_type = check_typedef (func_type);
   if (TYPE_CODE (func_type) == TYPE_CODE_PTR)
     func_type = check_typedef (TYPE_TARGET_TYPE (func_type));
 
   gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC
               || TYPE_CODE (func_type) == TYPE_CODE_METHOD);
 
   /* For a variadic C function, the last explicitly declared argument and all
      remaining arguments are passed on the stack.  */
   if (TYPE_VARARGS (func_type))
     first_arg_on_stack = TYPE_NFIELDS (func_type) - 1;
 
-  /* Now make space on the stack for the args.  If
-     cplus_return_struct_by_reference is 1, means GDB pass an extra parameter
-     in ARGS, which is useless here, skip it.  */
-  for (argnum = cplus_return_struct_by_reference; argnum < nargs; argnum++)
+  /* Now make space on the stack for the args.  */
+  for (argnum = 0; argnum < nargs; argnum++)
     {
       int len = align_up (TYPE_LENGTH (value_type (args[argnum])), 4);
       if (argnum >= 10 - argreg)
         references_offset += len;
       stack_offset += len;
     }
   sp -= stack_offset;
   /* SP should be 8-byte aligned, see C6000 ABI section 4.4.1
      Stack Alignment.  */
   sp = align_down (sp, 8);
   stack_offset = 4;
 
   /* Now load as many as possible of the first arguments into
      registers, and push the rest onto the stack.  Loop through args
      from first to last.  */
-  for (argnum = cplus_return_struct_by_reference; argnum < nargs; argnum++)
+  for (argnum = 0; argnum < nargs; argnum++)
     {
       const gdb_byte *val;
       struct value *arg = args[argnum];
       struct type *arg_type = check_typedef (value_type (arg));
       int len = TYPE_LENGTH (arg_type);
       enum type_code typecode = TYPE_CODE (arg_type);
 
       val = value_contents (arg);
 
       /* Copy the argument to general registers or the stack in
@@ skipping 200 matching lines @@
   /* JMP_BUF contains 13 elements of type int, and return address is stored
      in the last slot.  */
   if (target_read_memory (jb_addr + 12 * 4, buf, 4))
     return 0;
 
   *pc = extract_unsigned_integer (buf, 4, byte_order);
 
   return 1;
 }
 
+/* This is the implementation of gdbarch method
+   return_in_first_hidden_param_p.  */
+
+static int
+tic6x_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
+                                      struct type *type)
+{
+  return 0;
+}
+
 static struct gdbarch *
 tic6x_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 {
   struct gdbarch *gdbarch;
   struct gdbarch_tdep *tdep;
   struct tdesc_arch_data *tdesc_data = NULL;
   const struct target_desc *tdesc = info.target_desc;
   int has_gp = 0;
 
   /* Check any target description for validity.  */
@@ skipping 138 matching lines @@
 
   set_gdbarch_dummy_id (gdbarch, tic6x_dummy_id);
 
   /* Enable inferior call support.  */
   set_gdbarch_push_dummy_call (gdbarch, tic6x_push_dummy_call);
 
   set_gdbarch_get_longjmp_target (gdbarch, tic6x_get_longjmp_target);
 
   set_gdbarch_in_function_epilogue_p (gdbarch, tic6x_in_function_epilogue_p);
 
+  set_gdbarch_return_in_first_hidden_param_p (gdbarch,
+                                              tic6x_return_in_first_hidden_param_p);
+
   /* Hook in ABI-specific overrides, if they have been registered.  */
   gdbarch_init_osabi (info, gdbarch);
 
   if (tdesc_data)
     tdesc_use_registers (gdbarch, tdesc, tdesc_data);
 
   return gdbarch;
 }
 
+/* -Wmissing-prototypes */
+extern initialize_file_ftype _initialize_tic6x_tdep;
+
 void
 _initialize_tic6x_tdep (void)
 {
   register_gdbarch_init (bfd_arch_tic6x, tic6x_gdbarch_init);
 
   initialize_tdesc_tic6x_c64xp ();
   initialize_tdesc_tic6x_c64x ();
   initialize_tdesc_tic6x_c62x ();
 }