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.7.1/gdb/alpha-tdep.c

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

--- gdb-7.7.1.orig/gdb/alpha-tdep.c	2014-05-09 19:24:18.677252769 +0200

+++ gdb-7.7.1/gdb/alpha-tdep.c	2014-05-09 20:02:09.620703767 +0200

@@ -299,18 +299,18 @@ alpha_push_dummy_call (struct gdbarch *g

 {

   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

     = (struct alpha_arg *) alloca (nargs * sizeof (struct alpha_arg));

   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.  */

@@ -430,8 +430,8 @@ alpha_push_dummy_call (struct gdbarch *g

   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))

@@ -443,7 +443,7 @@ alpha_push_dummy_call (struct gdbarch *g

 	    }

 	  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.7.1/gdb/amd64-tdep.c

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

--- gdb-7.7.1.orig/gdb/amd64-tdep.c	2014-05-09 19:24:18.678252770 +0200

+++ gdb-7.7.1/gdb/amd64-tdep.c	2014-05-09 20:02:09.620703767 +0200

@@ -633,7 +633,7 @@ amd64_return_value (struct gdbarch *gdba

 		    gdb_byte *readbuf, const gdb_byte *writebuf)

 {

   enum amd64_reg_class class[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;

@@ -784,8 +784,8 @@ amd64_push_arguments (struct regcache *r

   };

   struct value **stack_args = alloca (nargs * sizeof (struct value *));

   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;

@@ -797,7 +797,7 @@ amd64_push_arguments (struct regcache *r

   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 class[2];

       int needed_integer_regs = 0;

       int needed_sse_regs = 0;

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

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

--- gdb-7.7.1.orig/gdb/amd64-windows-tdep.c	2014-05-09 19:24:18.679252770 +0200

+++ gdb-7.7.1/gdb/amd64-windows-tdep.c	2014-05-09 20:02:09.620703767 +0200

@@ -288,7 +288,7 @@ amd64_windows_return_value (struct gdbar

 			    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.7.1/gdb/arm-tdep.c

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

--- gdb-7.7.1.orig/gdb/arm-tdep.c	2014-05-09 19:24:18.684252770 +0200

+++ gdb-7.7.1/gdb/arm-tdep.c	2014-05-09 20:02:09.622703768 +0200

@@ -3498,7 +3498,7 @@ arm_vfp_cprc_reg_char (enum arm_vfp_cprc

    array).  Vectors and complex 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)

 {

@@ -3529,7 +3529,7 @@ arm_vfp_cprc_sub_candidate (struct type

     case TYPE_CODE_ARRAY:

       {

-	int count;

+	LONGEST count;

 	unsigned unitlen;

 	count = arm_vfp_cprc_sub_candidate (TYPE_TARGET_TYPE (t), base_type);

 	if (count == -1)

@@ -3549,13 +3549,15 @@ arm_vfp_cprc_sub_candidate (struct type

     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 = 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 += sub_count;

@@ -3575,13 +3577,15 @@ arm_vfp_cprc_sub_candidate (struct type

     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);

@@ -3617,7 +3621,7 @@ arm_vfp_call_candidate (struct type *t,

 			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;

@@ -3698,7 +3702,7 @@ arm_push_dummy_call (struct gdbarch *gdb

   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.7.1/gdb/avr-tdep.c

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

--- gdb-7.7.1.orig/gdb/avr-tdep.c	2014-05-09 19:24:18.686252771 +0200

+++ gdb-7.7.1/gdb/avr-tdep.c	2014-05-09 20:02:09.623703768 +0200

@@ -1167,13 +1167,14 @@ avr_dummy_id (struct gdbarch *gdbarch, s

 struct stack_item

 {

-  int len;

+  ssize_t len;

   struct stack_item *prev;

   void *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 = xmalloc (sizeof (struct stack_item));

@@ -1262,12 +1263,12 @@ avr_push_dummy_call (struct gdbarch *gdb

   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.  */

       last_regnum = regnum - (len + (len & 1));

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

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

--- gdb-7.7.1.orig/gdb/bfin-tdep.c	2014-05-09 19:24:18.686252771 +0200

+++ gdb-7.7.1/gdb/bfin-tdep.c	2014-05-09 20:02:09.623703768 +0200

@@ -506,7 +506,7 @@ bfin_push_dummy_call (struct gdbarch *gd

   gdb_byte buf[4];

   int i;

   long reg_r0, reg_r1, reg_r2;

-  int total_len = 0;

+  ssize_t total_len = 0;

   enum bfin_abi abi = bfin_abi (gdbarch);

   CORE_ADDR func_addr = find_function_addr (function, NULL);

@@ -530,7 +530,7 @@ bfin_push_dummy_call (struct gdbarch *gd

     {

       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_writeable (args[i]), container_len);

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

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

--- gdb-7.7.1.orig/gdb/cris-tdep.c	2014-05-09 19:24:18.687252771 +0200

+++ gdb-7.7.1/gdb/cris-tdep.c	2014-05-09 20:02:09.623703768 +0200

@@ -665,13 +665,13 @@ static CORE_ADDR cris_unwind_sp (struct

 struct stack_item

 {

-  int len;

+  ssize_t len;

   struct stack_item *prev;

   void *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;

   si = xmalloc (sizeof (struct stack_item));

@@ -844,13 +844,13 @@ cris_push_dummy_call (struct gdbarch *gd

   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.7.1/gdb/h8300-tdep.c

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

--- gdb-7.7.1.orig/gdb/h8300-tdep.c	2014-05-09 19:24:18.688252771 +0200

+++ gdb-7.7.1/gdb/h8300-tdep.c	2014-05-09 20:02:09.624703768 +0200

@@ -640,7 +640,7 @@ h8300_push_dummy_call (struct gdbarch *g

 		       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;

@@ -667,11 +667,11 @@ h8300_push_dummy_call (struct gdbarch *g

     {

       struct cleanup *back_to;

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

-      int len = TYPE_LENGTH (type);

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

+      ssize_t len = TYPE_LENGTH (type);

       /* Pad the argument appropriately.  */

-      int padded_len = align_up (len, wordsize);

+      ssize_t padded_len = align_up (len, wordsize);

       gdb_byte *padded = xmalloc (padded_len);

       back_to = make_cleanup (xfree, padded);

@@ -700,7 +700,7 @@ h8300_push_dummy_call (struct gdbarch *g

 	      /* 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.7.1/gdb/hppa-tdep.c

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

--- gdb-7.7.1.orig/gdb/hppa-tdep.c	2014-05-09 19:24:18.690252771 +0200

+++ gdb-7.7.1/gdb/hppa-tdep.c	2014-05-09 20:02:09.624703768 +0200

@@ -961,7 +961,7 @@ hppa64_push_dummy_call (struct gdbarch *

     {

       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;

@@ -1156,7 +1156,7 @@ hppa64_return_value (struct gdbarch *gdb

 		     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.7.1/gdb/i386-darwin-tdep.c

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

--- gdb-7.7.1.orig/gdb/i386-darwin-tdep.c	2014-05-09 19:24:18.690252771 +0200

+++ gdb-7.7.1/gdb/i386-darwin-tdep.c	2014-05-09 20:02:09.624703768 +0200

@@ -164,7 +164,7 @@ i386_darwin_push_dummy_call (struct gdba

   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.7.1/gdb/i386-tdep.c

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

--- gdb-7.7.1.orig/gdb/i386-tdep.c	2014-05-09 19:24:18.692252771 +0200

+++ gdb-7.7.1/gdb/i386-tdep.c	2014-05-09 20:02:09.625703769 +0200

@@ -2473,7 +2473,7 @@ i386_push_dummy_call (struct gdbarch *gd

   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

@@ -2481,7 +2481,7 @@ i386_push_dummy_call (struct gdbarch *gd

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

     {

-      int args_space_used = 0;

+      LONGEST args_space_used = 0;

       if (struct_return)

 	{

@@ -2498,7 +2498,7 @@ i386_push_dummy_call (struct gdbarch *gd

       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)

 	    {

@@ -2705,7 +2705,7 @@ i386_reg_struct_return_p (struct gdbarch

 {

   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

@@ -3249,7 +3249,7 @@ static int

 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

@@ -3282,7 +3282,7 @@ i386_register_to_value (struct frame_inf

 			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,

@@ -3318,7 +3318,7 @@ static void

 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.7.1/gdb/ia64-tdep.c

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

--- gdb-7.7.1.orig/gdb/ia64-tdep.c	2014-05-09 19:24:18.693252771 +0200

+++ gdb-7.7.1/gdb/ia64-tdep.c	2014-05-09 20:02:09.626703769 +0200

@@ -3851,8 +3851,10 @@ ia64_push_dummy_call (struct gdbarch *gd

   int argno;

   struct value *arg;

   struct type *type;

-  int len, argoffset;

-  int nslots, rseslots, memslots, slotnum, nfuncargs;

+  LONGEST argoffset;

+  LONGEST len;

+  int rseslots, slotnum, nfuncargs;

+  LONGEST nslots, memslots;

   int floatreg;

   ULONGEST bsp;

   CORE_ADDR funcdescaddr, pc, global_pointer;

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

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

--- gdb-7.7.1.orig/gdb/iq2000-tdep.c	2014-05-09 19:24:18.693252771 +0200

+++ gdb-7.7.1/gdb/iq2000-tdep.c	2014-05-09 20:02:09.626703769 +0200

@@ -654,8 +654,9 @@ iq2000_push_dummy_call (struct gdbarch *

   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.7.1/gdb/m32r-tdep.c

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

--- gdb-7.7.1.orig/gdb/m32r-tdep.c	2014-05-09 19:24:18.693252771 +0200

+++ gdb-7.7.1/gdb/m32r-tdep.c	2014-05-09 20:02:09.626703769 +0200

@@ -689,7 +689,7 @@ m32r_push_dummy_call (struct gdbarch *gd

   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.7.1/gdb/m68k-tdep.c

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

--- gdb-7.7.1.orig/gdb/m68k-tdep.c	2014-05-09 19:24:18.694252771 +0200

+++ gdb-7.7.1/gdb/m68k-tdep.c	2014-05-09 20:02:09.627703769 +0200

@@ -384,7 +384,7 @@ m68k_reg_struct_return_p (struct gdbarch

 {

   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);

@@ -516,9 +516,9 @@ m68k_push_dummy_call (struct gdbarch *gd

   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.7.1/gdb/m88k-tdep.c

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

--- gdb-7.7.1.orig/gdb/m88k-tdep.c	2014-05-09 19:24:18.694252771 +0200

+++ gdb-7.7.1/gdb/m88k-tdep.c	2014-05-09 20:02:09.627703769 +0200

@@ -260,13 +260,13 @@ m88k_store_arguments (struct regcache *r

 {

   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)

 	{

@@ -308,8 +308,8 @@ m88k_store_arguments (struct regcache *r

     {

       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.7.1/gdb/mep-tdep.c

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

--- gdb-7.7.1.orig/gdb/mep-tdep.c	2014-05-09 19:24:18.695252772 +0200

+++ gdb-7.7.1/gdb/mep-tdep.c	2014-05-09 20:02:09.627703769 +0200

@@ -2272,7 +2272,7 @@ push_large_arguments (CORE_ADDR sp, int

   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.7.1/gdb/mips-tdep.c

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

--- gdb-7.7.1.orig/gdb/mips-tdep.c	2014-05-09 19:24:18.698252772 +0200

+++ gdb-7.7.1/gdb/mips-tdep.c	2014-05-09 20:02:09.628703769 +0200

@@ -402,7 +402,7 @@ static void

 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;

@@ -425,8 +425,8 @@ mips_xfer_register (struct gdbarch *gdba

     }

   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;

@@ -4345,13 +4345,13 @@ mips_eabi_push_dummy_call (struct gdbarc

       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);

       /* Function pointer arguments to mips16 code need to be made into

          mips16 pointers.  */

@@ -4636,7 +4636,7 @@ mips_eabi_return_value (struct gdbarch *

 static int

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

-			    int offset)

+			    LONGEST offset)

 {

   int i;

@@ -4651,7 +4651,7 @@ mips_n32n64_fp_arg_chunk_p (struct gdbar

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

     {

-      int pos;

+      LONGEST pos;

       struct type *field_type;

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