http://sourceware.org/ml/gdb-patches/2012-09/msg00630.html

Subject: [PATCH 4/4] Bitpos expansion - tdep changes

--MP_/X_WjDOvz/B_fvlsrmCwRdxe

Content-Type: text/plain; charset=US-ASCII

Content-Transfer-Encoding: 7bit

Content-Disposition: inline

Hi,

This is the last part of the bitpos change.  This patch does the same

thing that patch 1/4 does, except that it does so in the *-tdep files

wherever necessary.  I separated these changes mainly because they are

related and can be reviewed independently.  Tested on Fedora 16 x86_64.

Regards,

Siddhesh

--MP_/X_WjDOvz/B_fvlsrmCwRdxe

Content-Type: text/plain

Content-Transfer-Encoding: quoted-printable

Content-Disposition: attachment; filename=ChangeLog-tdep

gdb/ChangeLog

	* alpha-tdep.c (alpha_push_dummy_call): Expand ACCUMULATE_SIZE,

	REQUIRED_ARG_REGS, OFFSET, LEN, TLEN to ssize_t.

	(struct alpha_arg): Expand members LEN, OFFSET to ssize_t.

	* amd64-tdep.c (amd64_push_arguments): Expand NUM_ELEMENTS,

	ELEMENT and LEN to LONGEST.

	(amd64_return_value): Expand LEN to LONGEST.

	* amd64-windows-tdep.c (amd64_windows_return_value): Expand LEN

	to LONGEST.

	* arm-tdep.c (arm_vfp_cprc_sub_candidate): Return LONGEST.

	Expand COUNT, SUB_COUNT to LONGEST.

	(arm_vfp_call_candidate): Expand C to LONGEST.

	(arm_push_dummy_call): Expand LEN to LONGEST.

	* avr-tdep.c (struct stack_item): Expand member LEN to ssize_t.

	(push_stack_item): Expand parameter LEN to ssize_t.

	(avr_push_dummy_call): Expand LAST_REGNUM, J, LEN to ssize_t.

	* bfin-tdep.c (bfin_push_dummy_call): Expand TOTAL_LEN,

	CONTAINER_LEN to ssize_t.

	* cris-tdep.c (struct stack_item): Expand member LEN to ssize_t.

	(push_stack_item): Expand parameter LEN to ssize_t.

	(cris_push_dummy_call): Expand LEN, REG_DEMAND, I to ssize_t.

	* h8300-tdep.c (h8300_push_dummy_call): Expand STACK_ALLOC,

	STACK_OFFSET to LONGEST.  Expand LEN, PADDED_LEN, OFFSET to

	ssize_t.

	* hppa-tdep.c (hppa64_push_dummy_call): Expand LEN to LONGEST.

	(hppa64_return_value): Likewise.

	* i386-darwin-tdep.c (i386_darwin_push_dummy_call): Expand

	ARGS_SPACE to LONGEST.

	* i386-tdep.c (i386_push_dummy_call): Expand ARG_SPACE,

	ARG_SPACE_USED, LEN to LONGEST.

	(i386_reg_struct_return_p): Expand LEN to LONGEST.

	(i386_convert_register_p): Likewise.

	(i386_register_to_value): Likewise.

	(i386_value_to_register): Likewise.

	* ia64-tdep.c (ia64_push_dummy_call): Expand ARGOFFSET, LEN,

	NSLOTS, MEMSLOTS to LONGEST.

	* iq2000-tdep.c (iq2000_push_dummy_call): Expand TYPELEN,

	STACKSPACE to LONGEST.

	* m32r-tdep.c (m32r_push_dummy_call): Expand LEN to LONGEST.

	* m68k-tdep.c (m68k_reg_struct_return_p): Expand LEN to LONGEST.

	(m68k_push_dummy_call): Expand LEN, CONTAINER_LEN, OFFSET to

	LONGEST.

	* m88k-tdep.c (m88k_store_arguments): Expand NUM_STACK_WORDS,

	LEN, STACK_WORD to LONGEST.

	* mep-tdep.c (push_large_arguments): Expand ARG_LEN to ULONGEST.

	* microblaze-tdep.c (microblaze_store_return_value): Expand LEN to

	LONGEST.

	* mips-tdep.c (mips_xfer_register): Expand parameter BUF_OFFSET to

	LONGEST.  Use plongest to format print BUF_OFFSET.

	(mips_eabi_push_dummy_call): Expand LEN to LONGEST.  Use plongest

	to format print LEN.

	(mips_n32n64_fp_arg_chunk_p): Expand parameter OFFSET to LONGEST.

	Expand POS to LONGEST.

	(mips_n32n64_push_dummy_call): Expand LEN to LONGEST.

	(mips_n32n64_return_value): Expand OFFSET to LONGEST.  Use

	plongest to format print OFFSET.

	(mips_o32_push_dummy_call): Expand LEN to LONGEST.  Use plongest

	to format print LEN.

	(mips_o64_push_dummy_call): Expand LEN, STACK_OFFSET to LONGEST.

	Use plongest to format print LEN.

	* mn10300-tdep.c (mn10300_push_dummy_call): Expand LEN to

	LONGEST.

	* mt-tdep.c (mt_push_dummy_call): Expand STACK_DEST, TYPELEN to

	LONGEST.

	* ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call): Expand

	ARGSPACE, ARGOFFSET, STRUCTOFFSET, LEN, to LONGEST.

	(ppc64_sysv_abi_push_dummy_call): Expand BYTE, LEN to ssize_t.

	* rl78-tdep.c (rl78_push_dummy_call): Expand LEN, CONTAINER_LEN

	to LONGEST.

	* rs6000-aix-tdep.c (rs6000_push_dummy_call): Expand ARGBYTES,

	LEN to LONGEST.

	(ran_out_of_registers_for_arguments): Expand SPACE, JJ to

	LONGEST.

	* s390-linux-tdep.c (s390_value_from_register): Expand LEN to LONGEST.

	(is_power_of_two): Expand parameter N to ULONGEST.

	(s390_push_dummy_call): Expand LENGTH to ULONGEST.

	* score-tdep.c (score_push_dummy_call): Expand ARGLEN to

	LONGEST.

	* sh-tdep.c (sh_use_struct_convention) Expand len to LONGEST.

	(sh_justify_value_in_reg): Expand parameter LEN to LONGEST.

	(sh_push_dummy_call_fpu): Expand LEN to LONGEST.  Expand REG_SIZE

	to ssize_t.

	(sh_push_dummy_call_nofpu): Likewise.

	* sh64-tdep.c (sh64_push_dummy_call): Expand STACK_OFFSET,

	STACK_ALLOC, LEN to LONGEST.

	* sparc-tdep.c (sparc32_store_arguments): Expand LEN to LONGEST.

	* sparc64-tdep.c (sparc64_store_floating_fields): Expand

	parameter BITPOS to LONGEST.  Expand SUBPOS to LONGEST.

	(sparc64_extract_floating_fields): Likewise.

	(sparc64_store_arguments): Expand LEN to LONGEST.

	* spu-tdep.c (spu_push_dummy_call): Expand N_REGS, LEN to LONGEST.

	(spu_value_from_register): Expand LEN to LONGEST.

	* tic6x-tdep.c (tic6x_push_dummy_call): Expand REFERENCES_OFFST,

	LEN to LONGEST.  Expand LEN to ssize_t.  Use plongest to format

	print LEN.

	* tilegx-tdep.c (tilegx_push_dummy_call): Expand TYPELEN,

	SLACKLEN, ALIGNLEN to LONGEST.

	* v850-tdep.c (v850_push_dummy_call): Expand LEN to LONGEST.

	* vax-tdep.c (vax_store_arguments): Expand COUNT, LEN to LONGEST.

	(vax_return_value): Expand LEN to LONGEST.

	* xstormy16-tdep.c (xstormy16_push_dummy_call): Expand J, TYPELEN

	to LONGEST.

	* xtensa-tdep.c (xtensa_store_return_value): Print LEN instead of

	TYPE_LENGTH..

	(struct argument_info): Expoand member LENGTH to ssize_t.

	(struct argument_info.u): Expand member OFFSET to ssize_t.

	(xtensa_push_dummy_call): Expand SIZE, ONSTACK_SIZE to LONGEST.

	Expand N to ssize_t.  Use pulongest to format print TYPE_LENGTH.

--MP_/X_WjDOvz/B_fvlsrmCwRdxe

Content-Type: text/x-patch

Content-Transfer-Encoding: 7bit

Content-Disposition: attachment; filename=bitpos-tdep.patch

Index: gdb-7.11.50.20160716/gdb/alpha-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/alpha-tdep.c	2016-07-16 14:35:45.390502718 +0200

+++ gdb-7.11.50.20160716/gdb/alpha-tdep.c	2016-07-16 14:35:47.511519788 +0200

@@ -299,17 +299,17 @@

 {

   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   int i;

-  int accumulate_size = struct_return ? 8 : 0;

+  ssize_t accumulate_size = struct_return ? 8 : 0;

   struct alpha_arg

     {

       const gdb_byte *contents;

-      int len;

-      int offset;

+      ssize_t len;

+      ssize_t offset;

     };

   struct alpha_arg *alpha_args = XALLOCAVEC (struct alpha_arg, nargs);

   struct alpha_arg *m_arg;

   gdb_byte arg_reg_buffer[ALPHA_REGISTER_SIZE * ALPHA_NUM_ARG_REGS];

-  int required_arg_regs;

+  ssize_t required_arg_regs;

   CORE_ADDR func_addr = find_function_addr (function, NULL);

   /* The ABI places the address of the called function in T12.  */

@@ -429,8 +429,8 @@

   for (i = nargs; m_arg--, --i >= 0;)

     {

       const gdb_byte *contents = m_arg->contents;

-      int offset = m_arg->offset;

-      int len = m_arg->len;

+      ssize_t offset = m_arg->offset;

+      ssize_t len = m_arg->len;

       /* Copy the bytes destined for registers into arg_reg_buffer.  */

       if (offset < sizeof(arg_reg_buffer))

@@ -442,7 +442,7 @@

 	    }

 	  else

 	    {

-	      int tlen = sizeof(arg_reg_buffer) - offset;

+	      ssize_t tlen = sizeof(arg_reg_buffer) - offset;

 	      memcpy (arg_reg_buffer + offset, contents, tlen);

 	      offset += tlen;

 	      contents += tlen;

Index: gdb-7.11.50.20160716/gdb/amd64-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/amd64-tdep.c	2016-07-16 14:35:45.391502726 +0200

+++ gdb-7.11.50.20160716/gdb/amd64-tdep.c	2016-07-16 14:35:47.512519796 +0200

@@ -729,7 +729,7 @@

 		    gdb_byte *readbuf, const gdb_byte *writebuf)

 {

   enum amd64_reg_class theclass[2];

-  int len = TYPE_LENGTH (type);

+  LONGEST len = TYPE_LENGTH (type);

   static int integer_regnum[] = { AMD64_RAX_REGNUM, AMD64_RDX_REGNUM };

   static int sse_regnum[] = { AMD64_XMM0_REGNUM, AMD64_XMM1_REGNUM };

   int integer_reg = 0;

@@ -880,8 +880,8 @@

   };

   struct value **stack_args = XALLOCAVEC (struct value *, nargs);

   int num_stack_args = 0;

-  int num_elements = 0;

-  int element = 0;

+  LONGEST num_elements = 0;

+  LONGEST element = 0;

   int integer_reg = 0;

   int sse_reg = 0;

   int i;

@@ -893,7 +893,7 @@

   for (i = 0; i < nargs; i++)

     {

       struct type *type = value_type (args[i]);

-      int len = TYPE_LENGTH (type);

+      LONGEST len = TYPE_LENGTH (type);

       enum amd64_reg_class theclass[2];

       int needed_integer_regs = 0;

       int needed_sse_regs = 0;

Index: gdb-7.11.50.20160716/gdb/amd64-windows-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/amd64-windows-tdep.c	2016-07-16 14:35:45.393502742 +0200

+++ gdb-7.11.50.20160716/gdb/amd64-windows-tdep.c	2016-07-16 14:35:47.512519796 +0200

@@ -288,7 +288,7 @@

 			    struct type *type, struct regcache *regcache,

 			    gdb_byte *readbuf, const gdb_byte *writebuf)

 {

-  int len = TYPE_LENGTH (type);

+  LONGEST len = TYPE_LENGTH (type);

   int regnum = -1;

   /* See if our value is returned through a register.  If it is, then

Index: gdb-7.11.50.20160716/gdb/arm-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/arm-tdep.c	2016-07-16 14:35:45.400502798 +0200

+++ gdb-7.11.50.20160716/gdb/arm-tdep.c	2016-07-16 14:36:30.328864376 +0200

@@ -3443,7 +3443,7 @@

    array).  Vector types are not currently supported, matching the

    generic AAPCS support.  */

-static int

+static LONGEST

 arm_vfp_cprc_sub_candidate (struct type *t,

 			    enum arm_vfp_cprc_base_type *base_type)

 {

@@ -3526,7 +3526,7 @@

 	  }

 	else

 	  {

-	    int count;

+	    LONGEST count;

 	    unsigned unitlen;

 	    count = arm_vfp_cprc_sub_candidate (TYPE_TARGET_TYPE (t),

@@ -3549,12 +3549,12 @@

     case TYPE_CODE_STRUCT:

       {

-	int count = 0;

+	LONGEST count = 0;

 	unsigned unitlen;

 	int i;

 	for (i = 0; i < TYPE_NFIELDS (t); i++)

 	  {

-	    int sub_count = 0;

+	    LONGEST sub_count = 0;

 	    if (!field_is_static (&TYPE_FIELD (t, i)))

 	      sub_count = arm_vfp_cprc_sub_candidate (TYPE_FIELD_TYPE (t, i),

@@ -3578,13 +3578,15 @@

     case TYPE_CODE_UNION:

       {

-	int count = 0;

+	LONGEST count = 0;

 	unsigned unitlen;

 	int i;

 	for (i = 0; i < TYPE_NFIELDS (t); i++)

 	  {

-	    int sub_count = arm_vfp_cprc_sub_candidate (TYPE_FIELD_TYPE (t, i),

-							base_type);

+	    LONGEST sub_count;

+

+	    sub_count = arm_vfp_cprc_sub_candidate (TYPE_FIELD_TYPE (t, i),

+						    base_type);

 	    if (sub_count == -1)

 	      return -1;

 	    count = (count > sub_count ? count : sub_count);

@@ -3620,7 +3622,7 @@

 			int *count)

 {

   enum arm_vfp_cprc_base_type b = VFP_CPRC_UNKNOWN;

-  int c = arm_vfp_cprc_sub_candidate (t, &b);

+  LONGEST c = arm_vfp_cprc_sub_candidate (t, &b);

   if (c <= 0 || c > 4)

     return 0;

   *base_type = b;

@@ -3701,7 +3703,7 @@

   for (argnum = 0; argnum < nargs; argnum++)

     {

-      int len;

+      LONGEST len;

       struct type *arg_type;

       struct type *target_type;

       enum type_code typecode;

Index: gdb-7.11.50.20160716/gdb/avr-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/avr-tdep.c	2016-07-16 14:35:45.401502806 +0200

+++ gdb-7.11.50.20160716/gdb/avr-tdep.c	2016-07-16 14:35:47.516519828 +0200

@@ -1195,13 +1195,13 @@

 struct stack_item

 {

-  int len;

+  ssize_t len;

   struct stack_item *prev;

   gdb_byte *data;

 };

 static struct stack_item *

-push_stack_item (struct stack_item *prev, const bfd_byte *contents, int len)

+push_stack_item (struct stack_item *prev, const bfd_byte *contents, ssize_t len)

 {

   struct stack_item *si;

   si = XNEW (struct stack_item);

@@ -1289,12 +1289,12 @@

   for (i = 0; i < nargs; i++)

     {

-      int last_regnum;

-      int j;

+      ssize_t last_regnum;

+      ssize_t j;

       struct value *arg = args[i];

       struct type *type = check_typedef (value_type (arg));

       const bfd_byte *contents = value_contents (arg);

-      int len = TYPE_LENGTH (type);

+      ssize_t len = TYPE_LENGTH (type);

       /* Calculate the potential last register needed.

          E.g. For length 2, registers regnum and regnum-1 (say 25 and 24)

Index: gdb-7.11.50.20160716/gdb/bfin-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/bfin-tdep.c	2016-07-16 14:35:45.401502806 +0200

+++ gdb-7.11.50.20160716/gdb/bfin-tdep.c	2016-07-16 14:35:47.516519828 +0200

@@ -502,7 +502,7 @@

   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   int i;

   long reg_r0, reg_r1, reg_r2;

-  int total_len = 0;

+  ssize_t total_len = 0;

   for (i = nargs - 1; i >= 0; i--)

     {

@@ -524,7 +524,7 @@

     {

       struct type *value_type = value_enclosing_type (args[i]);

       struct type *arg_type = check_typedef (value_type);

-      int container_len = (TYPE_LENGTH (value_type) + 3) & ~3;

+      ssize_t container_len = (TYPE_LENGTH (value_type) + 3) & ~3;

       sp -= container_len;

       write_memory (sp, value_contents (args[i]), container_len);

Index: gdb-7.11.50.20160716/gdb/cris-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/cris-tdep.c	2016-07-16 14:35:45.403502823 +0200

+++ gdb-7.11.50.20160716/gdb/cris-tdep.c	2016-07-16 14:35:47.517519836 +0200

@@ -663,13 +663,13 @@

 struct stack_item

 {

-  int len;

+  ssize_t len;

   struct stack_item *prev;

   gdb_byte *data;

 };

 static struct stack_item *

-push_stack_item (struct stack_item *prev, const gdb_byte *contents, int len)

+push_stack_item (struct stack_item *prev, const gdb_byte *contents, ssize_t len)

 {

   struct stack_item *si = XNEW (struct stack_item);

   si->data = (gdb_byte *) xmalloc (len);

@@ -833,13 +833,13 @@

   for (argnum = 0; argnum < nargs; argnum++)

     {

-      int len;

+      ssize_t len;

       const gdb_byte *val;

-      int reg_demand;

-      int i;

+      ssize_t reg_demand;

+      ssize_t i;

-      len = TYPE_LENGTH (value_type (args[argnum]));

       val = value_contents (args[argnum]);

+      len = TYPE_LENGTH (value_type (args[argnum]));

       /* How may registers worth of storage do we need for this argument?  */

       reg_demand = (len / 4) + (len % 4 != 0 ? 1 : 0);

Index: gdb-7.11.50.20160716/gdb/h8300-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/h8300-tdep.c	2016-07-16 14:35:45.403502823 +0200

+++ gdb-7.11.50.20160716/gdb/h8300-tdep.c	2016-07-16 14:35:47.517519836 +0200

@@ -637,7 +637,7 @@

 		       int struct_return, CORE_ADDR struct_addr)

 {

   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

-  int stack_alloc = 0, stack_offset = 0;

+  LONGEST stack_alloc = 0, stack_offset = 0;

   int wordsize = BINWORD (gdbarch);

   int reg = E_ARG0_REGNUM;

   int argument;

@@ -664,11 +664,11 @@

     {

       struct cleanup *back_to;

       struct type *type = value_type (args[argument]);

-      int len = TYPE_LENGTH (type);

+      ssize_t len = TYPE_LENGTH (type);

       char *contents = (char *) value_contents (args[argument]);

       /* Pad the argument appropriately.  */

-      int padded_len = align_up (len, wordsize);

+      ssize_t padded_len = align_up (len, wordsize);

       gdb_byte *padded = (gdb_byte *) xmalloc (padded_len);

       back_to = make_cleanup (xfree, padded);

@@ -697,7 +697,7 @@

 	      /* Heavens to Betsy --- it's really going in registers!

 	         Note that on the h8/300s, there are gaps between the

 	         registers in the register file.  */

-	      int offset;

+	      ssize_t offset;

 	      for (offset = 0; offset < padded_len; offset += wordsize)

 		{

Index: gdb-7.11.50.20160716/gdb/hppa-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/hppa-tdep.c	2016-07-16 14:35:45.405502839 +0200

+++ gdb-7.11.50.20160716/gdb/hppa-tdep.c	2016-07-16 14:35:47.518519844 +0200

@@ -991,7 +991,7 @@

     {

       struct value *arg = args[i];

       struct type *type = value_type (arg);

-      int len = TYPE_LENGTH (type);

+      LONGEST len = TYPE_LENGTH (type);

       const bfd_byte *valbuf;

       bfd_byte fptrbuf[8];

       int regnum;

@@ -1186,7 +1186,7 @@

 		     struct type *type, struct regcache *regcache,

 		     gdb_byte *readbuf, const gdb_byte *writebuf)

 {

-  int len = TYPE_LENGTH (type);

+  LONGEST len = TYPE_LENGTH (type);

   int regnum, offset;

   if (len > 16)

Index: gdb-7.11.50.20160716/gdb/i386-darwin-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/i386-darwin-tdep.c	2016-07-16 14:35:45.405502839 +0200

+++ gdb-7.11.50.20160716/gdb/i386-darwin-tdep.c	2016-07-16 14:35:47.518519844 +0200

@@ -163,7 +163,7 @@

   for (write_pass = 0; write_pass < 2; write_pass++)

     {

-      int args_space = 0;

+      LONGEST args_space = 0;

       int num_m128 = 0;

       if (struct_return)

Index: gdb-7.11.50.20160716/gdb/i386-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/i386-tdep.c	2016-07-16 14:35:45.410502879 +0200

+++ gdb-7.11.50.20160716/gdb/i386-tdep.c	2016-07-16 14:35:47.520519860 +0200

@@ -2664,7 +2664,7 @@

   gdb_byte buf[4];

   int i;

   int write_pass;

-  int args_space = 0;

+  LONGEST args_space = 0;

   /* Determine the total space required for arguments and struct

      return address in a first pass (allowing for 16-byte-aligned

@@ -2672,7 +2672,7 @@

   for (write_pass = 0; write_pass < 2; write_pass++)

     {

-      int args_space_used = 0;

+      LONGEST args_space_used = 0;

       if (struct_return)

 	{

@@ -2689,7 +2689,7 @@

       for (i = 0; i < nargs; i++)

 	{

-	  int len = TYPE_LENGTH (value_enclosing_type (args[i]));

+	  LONGEST len = TYPE_LENGTH (value_enclosing_type (args[i]));

 	  if (write_pass)

 	    {

@@ -2896,7 +2896,7 @@

 {

   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

   enum type_code code = TYPE_CODE (type);

-  int len = TYPE_LENGTH (type);

+  LONGEST len = TYPE_LENGTH (type);

   gdb_assert (code == TYPE_CODE_STRUCT

               || code == TYPE_CODE_UNION

@@ -3718,7 +3718,7 @@

 i386_convert_register_p (struct gdbarch *gdbarch,

 			 int regnum, struct type *type)

 {

-  int len = TYPE_LENGTH (type);

+  LONGEST len = TYPE_LENGTH (type);

   /* Values may be spread across multiple registers.  Most debugging

      formats aren't expressive enough to specify the locations, so

@@ -3751,7 +3751,7 @@

 			int *optimizedp, int *unavailablep)

 {

   struct gdbarch *gdbarch = get_frame_arch (frame);

-  int len = TYPE_LENGTH (type);

+  LONGEST len = TYPE_LENGTH (type);

   if (i386_fp_regnum_p (gdbarch, regnum))

     return i387_register_to_value (frame, regnum, type, to,

@@ -3787,7 +3787,7 @@

 i386_value_to_register (struct frame_info *frame, int regnum,

 			struct type *type, const gdb_byte *from)

 {

-  int len = TYPE_LENGTH (type);

+  LONGEST len = TYPE_LENGTH (type);

   if (i386_fp_regnum_p (get_frame_arch (frame), regnum))

     {

Index: gdb-7.11.50.20160716/gdb/iq2000-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/iq2000-tdep.c	2016-07-16 14:35:45.411502887 +0200

+++ gdb-7.11.50.20160716/gdb/iq2000-tdep.c	2016-07-16 14:35:47.520519860 +0200

@@ -646,8 +646,9 @@

   const bfd_byte *val;

   bfd_byte buf[4];

   struct type *type;

-  int i, argreg, typelen, slacklen;

-  int stackspace = 0;

+  int i, argreg, slacklen;

+  LONGEST typelen;

+  LONGEST stackspace = 0;

   /* Used to copy struct arguments into the stack.  */

   CORE_ADDR struct_ptr;

Index: gdb-7.11.50.20160716/gdb/m32r-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/m32r-tdep.c	2016-07-16 14:35:45.411502887 +0200

+++ gdb-7.11.50.20160716/gdb/m32r-tdep.c	2016-07-16 14:35:47.520519860 +0200

@@ -685,7 +685,7 @@

   CORE_ADDR regval;

   gdb_byte *val;

   gdb_byte valbuf[MAX_REGISTER_SIZE];

-  int len;

+  LONGEST len;

   /* First force sp to a 4-byte alignment.  */

   sp = sp & ~3;

Index: gdb-7.11.50.20160716/gdb/m68k-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/m68k-tdep.c	2016-07-16 14:35:45.412502895 +0200

+++ gdb-7.11.50.20160716/gdb/m68k-tdep.c	2016-07-16 14:35:47.520519860 +0200

@@ -382,7 +382,7 @@

 {

   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

   enum type_code code = TYPE_CODE (type);

-  int len = TYPE_LENGTH (type);

+  LONGEST len = TYPE_LENGTH (type);

   gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION

 	      || code == TYPE_CODE_COMPLEX);

@@ -514,9 +514,9 @@

   for (i = nargs - 1; i >= 0; i--)

     {

       struct type *value_type = value_enclosing_type (args[i]);

-      int len = TYPE_LENGTH (value_type);

-      int container_len = (len + 3) & ~3;

-      int offset;

+      LONGEST len = TYPE_LENGTH (value_type);

+      LONGEST container_len = (len + 3) & ~3;

+      LONGEST offset;

       /* Non-scalars bigger than 4 bytes are left aligned, others are

 	 right aligned.  */

Index: gdb-7.11.50.20160716/gdb/m88k-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/m88k-tdep.c	2016-07-16 14:35:45.412502895 +0200

+++ gdb-7.11.50.20160716/gdb/m88k-tdep.c	2016-07-16 14:35:47.521519868 +0200

@@ -257,13 +257,13 @@

 {

   struct gdbarch *gdbarch = get_regcache_arch (regcache);

   int num_register_words = 0;

-  int num_stack_words = 0;

+  LONGEST num_stack_words = 0;

   int i;

   for (i = 0; i < nargs; i++)

     {

       struct type *type = value_type (args[i]);

-      int len = TYPE_LENGTH (type);

+      LONGEST len = TYPE_LENGTH (type);

       if (m88k_integral_or_pointer_p (type) && len < 4)

 	{

@@ -305,8 +305,8 @@

     {

       const bfd_byte *valbuf = value_contents (args[i]);

       struct type *type = value_type (args[i]);

-      int len = TYPE_LENGTH (type);

-      int stack_word = num_stack_words;

+      LONGEST len = TYPE_LENGTH (type);

+      LONGEST stack_word = num_stack_words;

       if (m88k_in_register_p (type))

 	{

Index: gdb-7.11.50.20160716/gdb/mep-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/mep-tdep.c	2016-07-16 14:35:45.413502903 +0200

+++ gdb-7.11.50.20160716/gdb/mep-tdep.c	2016-07-16 14:35:47.521519868 +0200

@@ -2272,7 +2272,7 @@

   for (i = 0; i < argc; i++)

     {

-      unsigned arg_len = TYPE_LENGTH (value_type (argv[i]));

+      ULONGEST arg_len = TYPE_LENGTH (value_type (argv[i]));

       if (arg_len > MEP_GPR_SIZE)

         {

Index: gdb-7.11.50.20160716/gdb/mips-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/mips-tdep.c	2016-07-16 14:35:45.421502967 +0200

+++ gdb-7.11.50.20160716/gdb/mips-tdep.c	2016-07-16 14:35:47.523519884 +0200

@@ -455,7 +455,7 @@

 mips_xfer_register (struct gdbarch *gdbarch, struct regcache *regcache,

 		    int reg_num, int length,

 		    enum bfd_endian endian, gdb_byte *in,

-		    const gdb_byte *out, int buf_offset)

+		    const gdb_byte *out, LONGEST buf_offset)

 {

   int reg_offset = 0;

@@ -478,8 +478,8 @@

     }

   if (mips_debug)

     fprintf_unfiltered (gdb_stderr,

-			"xfer $%d, reg offset %d, buf offset %d, length %d, ",

-			reg_num, reg_offset, buf_offset, length);

+			"xfer $%d, reg offset %d, buf offset %s, length %d, ",

+			reg_num, reg_offset, plongest (buf_offset), length);

   if (mips_debug && out != NULL)

     {

       int i;

@@ -4529,13 +4529,13 @@

       gdb_byte valbuf[MAX_REGISTER_SIZE];

       struct value *arg = args[argnum];

       struct type *arg_type = check_typedef (value_type (arg));

-      int len = TYPE_LENGTH (arg_type);

+      LONGEST len = TYPE_LENGTH (arg_type);

       enum type_code typecode = TYPE_CODE (arg_type);

       if (mips_debug)

 	fprintf_unfiltered (gdb_stdlog,

-			    "mips_eabi_push_dummy_call: %d len=%d type=%d",

-			    argnum + 1, len, (int) typecode);

+			    "mips_eabi_push_dummy_call: %d len=%s type=%d",

+			    argnum + 1, plongest (len), (int) typecode);

       /* The EABI passes structures that do not fit in a register by

          reference.  */

@@ -4804,7 +4804,7 @@

 static int

 mips_n32n64_fp_arg_chunk_p (struct gdbarch *gdbarch, struct type *arg_type,

-			    int offset)

+			    LONGEST offset)

 {

   int i;

@@ -4819,7 +4819,7 @@

   for (i = 0; i < TYPE_NFIELDS (arg_type); i++)

     {

-      int pos;

+      LONGEST pos;

       struct type *field_type;

       /* We're only looking at normal fields.  */

@@ -4861,7 +4861,7 @@

   int argreg;

   int float_argreg;

   int argnum;

-  int len = 0;

+  LONGEST len = 0;

   int stack_offset = 0;

   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   CORE_ADDR func_addr = find_function_addr (function, NULL);

@@ -5212,11 +5212,11 @@

 				: MIPS_V0_REGNUM);

 	   field < TYPE_NFIELDS (type); field++, regnum += 2)

 	{

-	  int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])

-			/ TARGET_CHAR_BIT);

+	  LONGEST offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])

+			    / TARGET_CHAR_BIT);

 	  if (mips_debug)

-	    fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n",

-				offset);

+	    fprintf_unfiltered (gdb_stderr, "Return float struct+%s\n",

+				plongest (offset));

 	  if (TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)) == 16)

 	    {

 	      /* A 16-byte long double field goes in two consecutive

@@ -5258,8 +5258,8 @@

 	  if (offset + xfer > TYPE_LENGTH (type))

 	    xfer = TYPE_LENGTH (type) - offset;

 	  if (mips_debug)

-	    fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",

-				offset, xfer, regnum);

+	    fprintf_unfiltered (gdb_stderr, "Return struct+%s:%d in $%d\n",

+				plongest (offset), xfer, regnum);

 	  mips_xfer_register (gdbarch, regcache,

 			      gdbarch_num_regs (gdbarch) + regnum,

 			      xfer, BFD_ENDIAN_UNKNOWN, readbuf, writebuf,

@@ -5317,7 +5317,7 @@

   int argreg;

   int float_argreg;

   int argnum;

-  int len = 0;

+  LONGEST len = 0;

   int stack_offset = 0;

   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   CORE_ADDR func_addr = find_function_addr (function, NULL);

@@ -5381,13 +5381,13 @@

       const gdb_byte *val;

       struct value *arg = args[argnum];

       struct type *arg_type = check_typedef (value_type (arg));

-      int len = TYPE_LENGTH (arg_type);

+      LONGEST len = TYPE_LENGTH (arg_type);

       enum type_code typecode = TYPE_CODE (arg_type);

       if (mips_debug)

 	fprintf_unfiltered (gdb_stdlog,

-			    "mips_o32_push_dummy_call: %d len=%d type=%d",

-			    argnum + 1, len, (int) typecode);

+			    "mips_o32_push_dummy_call: %d len=%s type=%d",

+			    argnum + 1, plongest (len), (int) typecode);

       val = value_contents (arg);

@@ -5842,8 +5842,8 @@

   int argreg;

   int float_argreg;

   int argnum;

-  int len = 0;

-  int stack_offset = 0;

+  LONGEST len = 0;

+  LONGEST stack_offset = 0;

   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   CORE_ADDR func_addr = find_function_addr (function, NULL);

@@ -5903,13 +5903,13 @@

       const gdb_byte *val;

       struct value *arg = args[argnum];

       struct type *arg_type = check_typedef (value_type (arg));

-      int len = TYPE_LENGTH (arg_type);

+      LONGEST len = TYPE_LENGTH (arg_type);

       enum type_code typecode = TYPE_CODE (arg_type);

       if (mips_debug)

 	fprintf_unfiltered (gdb_stdlog,

-			    "mips_o64_push_dummy_call: %d len=%d type=%d",

-			    argnum + 1, len, (int) typecode);

+			    "mips_o64_push_dummy_call: %d len=%s type=%d",

+			    argnum + 1, plongest (len), (int) typecode);

       val = value_contents (arg);

Index: gdb-7.11.50.20160716/gdb/mn10300-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/mn10300-tdep.c	2016-07-16 14:35:45.422502976 +0200

+++ gdb-7.11.50.20160716/gdb/mn10300-tdep.c	2016-07-16 14:35:47.524519892 +0200

@@ -1225,7 +1225,7 @@

   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   const int push_size = register_size (gdbarch, E_PC_REGNUM);

   int regs_used;

-  int len, arg_len; 

+  LONGEST len, arg_len; 

   int stack_offset = 0;

   int argnum;

   const gdb_byte *val;

Index: gdb-7.11.50.20160716/gdb/mt-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/mt-tdep.c	2016-07-16 14:35:45.423502984 +0200

+++ gdb-7.11.50.20160716/gdb/mt-tdep.c	2016-07-16 14:35:47.524519892 +0200

@@ -780,9 +780,9 @@

   gdb_byte buf[MT_MAX_STRUCT_SIZE];

   int argreg = MT_1ST_ARGREG;

   int split_param_len = 0;

-  int stack_dest = sp;

+  LONGEST stack_dest = sp;

   int slacklen;

-  int typelen;

+  LONGEST typelen;

   int i, j;

   /* First handle however many args we can fit into MT_1ST_ARGREG thru

Index: gdb-7.11.50.20160716/gdb/ppc-sysv-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/ppc-sysv-tdep.c	2016-07-16 14:35:45.424502992 +0200

+++ gdb-7.11.50.20160716/gdb/ppc-sysv-tdep.c	2016-07-16 14:35:47.524519892 +0200

@@ -66,7 +66,7 @@

   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   int opencl_abi = ppc_sysv_use_opencl_abi (value_type (function));

   ULONGEST saved_sp;

-  int argspace = 0;		/* 0 is an initial wrong guess.  */

+  LONGEST argspace = 0;		/* 0 is an initial wrong guess.  */

   int write_pass;

   gdb_assert (tdep->wordsize == 4);

@@ -97,9 +97,9 @@

       /* Next available vector register for vector arguments.  */

       int vreg = 2;

       /* Arguments start above the "LR save word" and "Back chain".  */

-      int argoffset = 2 * tdep->wordsize;

+      LONGEST argoffset = 2 * tdep->wordsize;

       /* Structures start after the arguments.  */

-      int structoffset = argoffset + argspace;

+      LONGEST structoffset = argoffset + argspace;

       /* If the function is returning a `struct', then the first word

          (which will be passed in r3) is used for struct return

@@ -118,7 +118,7 @@

 	{

 	  struct value *arg = args[argno];

 	  struct type *type = check_typedef (value_type (arg));

-	  int len = TYPE_LENGTH (type);

+	  ssize_t len = TYPE_LENGTH (type);

 	  const bfd_byte *val = value_contents (arg);

 	  if (TYPE_CODE (type) == TYPE_CODE_FLT && len <= 8

@@ -1283,11 +1283,11 @@

 static void

 ppc64_sysv_abi_push_val (struct gdbarch *gdbarch,

-			 const bfd_byte *val, int len, int align,

+			 const bfd_byte *val, ssize_t len, int align,

 			 struct ppc64_sysv_argpos *argpos)

 {

   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

-  int offset = 0;

+  ssize_t offset = 0;

   /* Enforce alignment of stack location, if requested.  */

   if (align > tdep->wordsize)

Index: gdb-7.11.50.20160716/gdb/rl78-tdep.c

===================================================================

--- gdb-7.11.50.20160716.orig/gdb/rl78-tdep.c	2016-07-16 14:35:45.424502992 +0200

+++ gdb-7.11.50.20160716/gdb/rl78-tdep.c	2016-07-16 14:35:47.525519900 +0200

@@ -1336,8 +1336,8 @@

   for (i = nargs - 1; i >= 0; i--)

     {

       struct type *value_type = value_enclosing_type (args[i]);

-      int len = TYPE_LENGTH (value_type);

-      int container_len = (len + 1) & ~1;

+      LONGEST len = TYPE_LENGTH (value_type);

+      LONGEST container_len = (len + 1) & ~1;