Blame SOURCES/gdb-rhbz795424-bitpos-23of25.patch

861f93
http://sourceware.org/ml/gdb-patches/2012-09/msg00630.html
861f93
Subject: [PATCH 4/4] Bitpos expansion - tdep changes
861f93
861f93
861f93
--MP_/X_WjDOvz/B_fvlsrmCwRdxe
861f93
Content-Type: text/plain; charset=US-ASCII
861f93
Content-Transfer-Encoding: 7bit
861f93
Content-Disposition: inline
861f93
861f93
Hi,
861f93
861f93
This is the last part of the bitpos change.  This patch does the same
861f93
thing that patch 1/4 does, except that it does so in the *-tdep files
861f93
wherever necessary.  I separated these changes mainly because they are
861f93
related and can be reviewed independently.  Tested on Fedora 16 x86_64.
861f93
861f93
Regards,
861f93
Siddhesh
861f93
861f93
--MP_/X_WjDOvz/B_fvlsrmCwRdxe
861f93
Content-Type: text/plain
861f93
Content-Transfer-Encoding: quoted-printable
861f93
Content-Disposition: attachment; filename=ChangeLog-tdep
861f93
861f93
gdb/ChangeLog
861f93
861f93
	* alpha-tdep.c (alpha_push_dummy_call): Expand ACCUMULATE_SIZE,
861f93
	REQUIRED_ARG_REGS, OFFSET, LEN, TLEN to ssize_t.
861f93
	(struct alpha_arg): Expand members LEN, OFFSET to ssize_t.
861f93
	* amd64-tdep.c (amd64_push_arguments): Expand NUM_ELEMENTS,
861f93
	ELEMENT and LEN to LONGEST.
861f93
	(amd64_return_value): Expand LEN to LONGEST.
861f93
	* amd64-windows-tdep.c (amd64_windows_return_value): Expand LEN
861f93
	to LONGEST.
861f93
	* arm-tdep.c (arm_vfp_cprc_sub_candidate): Return LONGEST.
861f93
	Expand COUNT, SUB_COUNT to LONGEST.
861f93
	(arm_vfp_call_candidate): Expand C to LONGEST.
861f93
	(arm_push_dummy_call): Expand LEN to LONGEST.
861f93
	* avr-tdep.c (struct stack_item): Expand member LEN to ssize_t.
861f93
	(push_stack_item): Expand parameter LEN to ssize_t.
861f93
	(avr_push_dummy_call): Expand LAST_REGNUM, J, LEN to ssize_t.
861f93
	* bfin-tdep.c (bfin_push_dummy_call): Expand TOTAL_LEN,
861f93
	CONTAINER_LEN to ssize_t.
861f93
	* cris-tdep.c (struct stack_item): Expand member LEN to ssize_t.
861f93
	(push_stack_item): Expand parameter LEN to ssize_t.
861f93
	(cris_push_dummy_call): Expand LEN, REG_DEMAND, I to ssize_t.
861f93
	* h8300-tdep.c (h8300_push_dummy_call): Expand STACK_ALLOC,
861f93
	STACK_OFFSET to LONGEST.  Expand LEN, PADDED_LEN, OFFSET to
861f93
	ssize_t.
861f93
	* hppa-tdep.c (hppa64_push_dummy_call): Expand LEN to LONGEST.
861f93
	(hppa64_return_value): Likewise.
861f93
	* i386-darwin-tdep.c (i386_darwin_push_dummy_call): Expand
861f93
	ARGS_SPACE to LONGEST.
861f93
	* i386-tdep.c (i386_push_dummy_call): Expand ARG_SPACE,
861f93
	ARG_SPACE_USED, LEN to LONGEST.
861f93
	(i386_reg_struct_return_p): Expand LEN to LONGEST.
861f93
	(i386_convert_register_p): Likewise.
861f93
	(i386_register_to_value): Likewise.
861f93
	(i386_value_to_register): Likewise.
861f93
	* ia64-tdep.c (ia64_push_dummy_call): Expand ARGOFFSET, LEN,
861f93
	NSLOTS, MEMSLOTS to LONGEST.
861f93
	* iq2000-tdep.c (iq2000_push_dummy_call): Expand TYPELEN,
861f93
	STACKSPACE to LONGEST.
861f93
	* m32r-tdep.c (m32r_push_dummy_call): Expand LEN to LONGEST.
861f93
	* m68k-tdep.c (m68k_reg_struct_return_p): Expand LEN to LONGEST.
861f93
	(m68k_push_dummy_call): Expand LEN, CONTAINER_LEN, OFFSET to
861f93
	LONGEST.
861f93
	* m88k-tdep.c (m88k_store_arguments): Expand NUM_STACK_WORDS,
861f93
	LEN, STACK_WORD to LONGEST.
861f93
	* mep-tdep.c (push_large_arguments): Expand ARG_LEN to ULONGEST.
861f93
	* microblaze-tdep.c (microblaze_store_return_value): Expand LEN to
861f93
	LONGEST.
861f93
	* mips-tdep.c (mips_xfer_register): Expand parameter BUF_OFFSET to
861f93
	LONGEST.  Use plongest to format print BUF_OFFSET.
861f93
	(mips_eabi_push_dummy_call): Expand LEN to LONGEST.  Use plongest
861f93
	to format print LEN.
861f93
	(mips_n32n64_fp_arg_chunk_p): Expand parameter OFFSET to LONGEST.
861f93
	Expand POS to LONGEST.
861f93
	(mips_n32n64_push_dummy_call): Expand LEN to LONGEST.
861f93
	(mips_n32n64_return_value): Expand OFFSET to LONGEST.  Use
861f93
	plongest to format print OFFSET.
861f93
	(mips_o32_push_dummy_call): Expand LEN to LONGEST.  Use plongest
861f93
	to format print LEN.
861f93
	(mips_o64_push_dummy_call): Expand LEN, STACK_OFFSET to LONGEST.
861f93
	Use plongest to format print LEN.
861f93
	* mn10300-tdep.c (mn10300_push_dummy_call): Expand LEN to
861f93
	LONGEST.
861f93
	* mt-tdep.c (mt_push_dummy_call): Expand STACK_DEST, TYPELEN to
861f93
	LONGEST.
861f93
	* ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call): Expand
861f93
	ARGSPACE, ARGOFFSET, STRUCTOFFSET, LEN, to LONGEST.
861f93
	(ppc64_sysv_abi_push_dummy_call): Expand BYTE, LEN to ssize_t.
861f93
	* rl78-tdep.c (rl78_push_dummy_call): Expand LEN, CONTAINER_LEN
861f93
	to LONGEST.
861f93
	* rs6000-aix-tdep.c (rs6000_push_dummy_call): Expand ARGBYTES,
861f93
	LEN to LONGEST.
861f93
	(ran_out_of_registers_for_arguments): Expand SPACE, JJ to
861f93
	LONGEST.
861f93
	* s390-tdep.c (s390_value_from_register): Expand LEN to LONGEST.
861f93
	(is_power_of_two): Expand parameter N to ULONGEST.
861f93
	(s390_push_dummy_call): Expand LENGTH to ULONGEST.
861f93
	* score-tdep.c (score_push_dummy_call): Expand ARGLEN to
861f93
	LONGEST.
861f93
	* sh-tdep.c (sh_use_struct_convention) Expand len to LONGEST.
861f93
	(sh_justify_value_in_reg): Expand parameter LEN to LONGEST.
861f93
	(sh_push_dummy_call_fpu): Expand LEN to LONGEST.  Expand REG_SIZE
861f93
	to ssize_t.
861f93
	(sh_push_dummy_call_nofpu): Likewise.
861f93
	* sh64-tdep.c (sh64_push_dummy_call): Expand STACK_OFFSET,
861f93
	STACK_ALLOC, LEN to LONGEST.
861f93
	* sparc-tdep.c (sparc32_store_arguments): Expand LEN to LONGEST.
861f93
	* sparc64-tdep.c (sparc64_store_floating_fields): Expand
861f93
	parameter BITPOS to LONGEST.  Expand SUBPOS to LONGEST.
861f93
	(sparc64_extract_floating_fields): Likewise.
861f93
	(sparc64_store_arguments): Expand LEN to LONGEST.
861f93
	* spu-tdep.c (spu_push_dummy_call): Expand N_REGS, LEN to LONGEST.
861f93
	(spu_value_from_register): Expand LEN to LONGEST.
861f93
	* tic6x-tdep.c (tic6x_push_dummy_call): Expand REFERENCES_OFFST,
861f93
	LEN to LONGEST.  Expand LEN to ssize_t.  Use plongest to format
861f93
	print LEN.
861f93
	* tilegx-tdep.c (tilegx_push_dummy_call): Expand TYPELEN,
861f93
	SLACKLEN, ALIGNLEN to LONGEST.
861f93
	* v850-tdep.c (v850_push_dummy_call): Expand LEN to LONGEST.
861f93
	* vax-tdep.c (vax_store_arguments): Expand COUNT, LEN to LONGEST.
861f93
	(vax_return_value): Expand LEN to LONGEST.
861f93
	* xstormy16-tdep.c (xstormy16_push_dummy_call): Expand J, TYPELEN
861f93
	to LONGEST.
861f93
	* xtensa-tdep.c (xtensa_store_return_value): Print LEN instead of
861f93
	TYPE_LENGTH..
861f93
	(struct argument_info): Expoand member LENGTH to ssize_t.
861f93
	(struct argument_info.u): Expand member OFFSET to ssize_t.
861f93
	(xtensa_push_dummy_call): Expand SIZE, ONSTACK_SIZE to LONGEST.
861f93
	Expand N to ssize_t.  Use pulongest to format print TYPE_LENGTH.
861f93
861f93
--MP_/X_WjDOvz/B_fvlsrmCwRdxe
861f93
Content-Type: text/x-patch
861f93
Content-Transfer-Encoding: 7bit
861f93
Content-Disposition: attachment; filename=bitpos-tdep.patch
861f93
861f93
Index: gdb-7.5.50.20130310/gdb/alpha-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/alpha-tdep.c	2013-03-10 16:44:34.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/alpha-tdep.c	2013-03-10 16:44:42.111599838 +0100
861f93
@@ -299,18 +299,18 @@ alpha_push_dummy_call (struct gdbarch *g
861f93
 {
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   int i;
861f93
-  int accumulate_size = struct_return ? 8 : 0;
861f93
+  ssize_t accumulate_size = struct_return ? 8 : 0;
861f93
   struct alpha_arg
861f93
     {
861f93
       const gdb_byte *contents;
861f93
-      int len;
861f93
-      int offset;
861f93
+      ssize_t len;
861f93
+      ssize_t offset;
861f93
     };
861f93
   struct alpha_arg *alpha_args
861f93
     = (struct alpha_arg *) alloca (nargs * sizeof (struct alpha_arg));
861f93
   struct alpha_arg *m_arg;
861f93
   gdb_byte arg_reg_buffer[ALPHA_REGISTER_SIZE * ALPHA_NUM_ARG_REGS];
861f93
-  int required_arg_regs;
861f93
+  ssize_t required_arg_regs;
861f93
   CORE_ADDR func_addr = find_function_addr (function, NULL);
861f93
 
861f93
   /* The ABI places the address of the called function in T12.  */
861f93
@@ -430,8 +430,8 @@ alpha_push_dummy_call (struct gdbarch *g
861f93
   for (i = nargs; m_arg--, --i >= 0;)
861f93
     {
861f93
       const gdb_byte *contents = m_arg->contents;
861f93
-      int offset = m_arg->offset;
861f93
-      int len = m_arg->len;
861f93
+      ssize_t offset = m_arg->offset;
861f93
+      ssize_t len = m_arg->len;
861f93
 
861f93
       /* Copy the bytes destined for registers into arg_reg_buffer.  */
861f93
       if (offset < sizeof(arg_reg_buffer))
861f93
@@ -443,7 +443,7 @@ alpha_push_dummy_call (struct gdbarch *g
861f93
 	    }
861f93
 	  else
861f93
 	    {
861f93
-	      int tlen = sizeof(arg_reg_buffer) - offset;
861f93
+	      ssize_t tlen = sizeof(arg_reg_buffer) - offset;
861f93
 	      memcpy (arg_reg_buffer + offset, contents, tlen);
861f93
 	      offset += tlen;
861f93
 	      contents += tlen;
861f93
Index: gdb-7.5.50.20130310/gdb/amd64-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/amd64-tdep.c	2013-03-10 16:16:23.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/amd64-tdep.c	2013-03-10 16:44:42.112599838 +0100
861f93
@@ -616,7 +616,7 @@ amd64_return_value (struct gdbarch *gdba
861f93
 {
861f93
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
861f93
   enum amd64_reg_class class[2];
861f93
-  int len = TYPE_LENGTH (type);
861f93
+  LONGEST len = TYPE_LENGTH (type);
861f93
   static int integer_regnum[] = { AMD64_RAX_REGNUM, AMD64_RDX_REGNUM };
861f93
   static int sse_regnum[] = { AMD64_XMM0_REGNUM, AMD64_XMM1_REGNUM };
861f93
   int integer_reg = 0;
861f93
@@ -769,8 +769,8 @@ amd64_push_arguments (struct regcache *r
861f93
      that register number (or a negative value otherwise).  */
861f93
   int *arg_addr_regno = alloca (nargs * sizeof (int));
861f93
   int num_stack_args = 0;
861f93
-  int num_elements = 0;
861f93
-  int element = 0;
861f93
+  LONGEST num_elements = 0;
861f93
+  LONGEST element = 0;
861f93
   int integer_reg = 0;
861f93
   int sse_reg = 0;
861f93
   int i;
861f93
@@ -784,7 +784,7 @@ amd64_push_arguments (struct regcache *r
861f93
   for (i = 0; i < nargs; i++)
861f93
     {
861f93
       struct type *type = value_type (args[i]);
861f93
-      int len = TYPE_LENGTH (type);
861f93
+      LONGEST len = TYPE_LENGTH (type);
861f93
       enum amd64_reg_class class[2];
861f93
       int needed_integer_regs = 0;
861f93
       int needed_sse_regs = 0;
861f93
Index: gdb-7.5.50.20130310/gdb/amd64-windows-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/amd64-windows-tdep.c	2013-01-01 07:32:37.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/amd64-windows-tdep.c	2013-03-10 16:44:42.112599838 +0100
861f93
@@ -79,7 +79,7 @@ amd64_windows_return_value (struct gdbar
861f93
 			    struct type *type, struct regcache *regcache,
861f93
 			    gdb_byte *readbuf, const gdb_byte *writebuf)
861f93
 {
861f93
-  int len = TYPE_LENGTH (type);
861f93
+  LONGEST len = TYPE_LENGTH (type);
861f93
   int regnum = -1;
861f93
 
861f93
   /* See if our value is returned through a register.  If it is, then
861f93
Index: gdb-7.5.50.20130310/gdb/arm-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/arm-tdep.c	2013-03-01 16:38:23.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/arm-tdep.c	2013-03-10 16:44:42.115599840 +0100
861f93
@@ -3496,7 +3496,7 @@ arm_vfp_cprc_reg_char (enum arm_vfp_cprc
861f93
    array).  Vectors and complex types are not currently supported,
861f93
    matching the generic AAPCS support.  */
861f93
 
861f93
-static int
861f93
+static LONGEST
861f93
 arm_vfp_cprc_sub_candidate (struct type *t,
861f93
 			    enum arm_vfp_cprc_base_type *base_type)
861f93
 {
861f93
@@ -3527,7 +3527,7 @@ arm_vfp_cprc_sub_candidate (struct type
861f93
 
861f93
     case TYPE_CODE_ARRAY:
861f93
       {
861f93
-	int count;
861f93
+	LONGEST count;
861f93
 	unsigned unitlen;
861f93
 	count = arm_vfp_cprc_sub_candidate (TYPE_TARGET_TYPE (t), base_type);
861f93
 	if (count == -1)
861f93
@@ -3547,13 +3547,15 @@ arm_vfp_cprc_sub_candidate (struct type
861f93
 
861f93
     case TYPE_CODE_STRUCT:
861f93
       {
861f93
-	int count = 0;
861f93
+	LONGEST count = 0;
861f93
 	unsigned unitlen;
861f93
 	int i;
861f93
 	for (i = 0; i < TYPE_NFIELDS (t); i++)
861f93
 	  {
861f93
-	    int sub_count = arm_vfp_cprc_sub_candidate (TYPE_FIELD_TYPE (t, i),
861f93
-							base_type);
861f93
+	    LONGEST sub_count;
861f93
+
861f93
+	    sub_count = arm_vfp_cprc_sub_candidate (TYPE_FIELD_TYPE (t, i),
861f93
+						    base_type);
861f93
 	    if (sub_count == -1)
861f93
 	      return -1;
861f93
 	    count += sub_count;
861f93
@@ -3573,13 +3575,15 @@ arm_vfp_cprc_sub_candidate (struct type
861f93
 
861f93
     case TYPE_CODE_UNION:
861f93
       {
861f93
-	int count = 0;
861f93
+	LONGEST count = 0;
861f93
 	unsigned unitlen;
861f93
 	int i;
861f93
 	for (i = 0; i < TYPE_NFIELDS (t); i++)
861f93
 	  {
861f93
-	    int sub_count = arm_vfp_cprc_sub_candidate (TYPE_FIELD_TYPE (t, i),
861f93
-							base_type);
861f93
+	    LONGEST sub_count;
861f93
+
861f93
+	    sub_count = arm_vfp_cprc_sub_candidate (TYPE_FIELD_TYPE (t, i),
861f93
+						    base_type);
861f93
 	    if (sub_count == -1)
861f93
 	      return -1;
861f93
 	    count = (count > sub_count ? count : sub_count);
861f93
@@ -3615,7 +3619,7 @@ arm_vfp_call_candidate (struct type *t,
861f93
 			int *count)
861f93
 {
861f93
   enum arm_vfp_cprc_base_type b = VFP_CPRC_UNKNOWN;
861f93
-  int c = arm_vfp_cprc_sub_candidate (t, &b);
861f93
+  LONGEST c = arm_vfp_cprc_sub_candidate (t, &b);
861f93
   if (c <= 0 || c > 4)
861f93
     return 0;
861f93
   *base_type = b;
861f93
@@ -3696,7 +3700,7 @@ arm_push_dummy_call (struct gdbarch *gdb
861f93
 
861f93
   for (argnum = 0; argnum < nargs; argnum++)
861f93
     {
861f93
-      int len;
861f93
+      LONGEST len;
861f93
       struct type *arg_type;
861f93
       struct type *target_type;
861f93
       enum type_code typecode;
861f93
Index: gdb-7.5.50.20130310/gdb/avr-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/avr-tdep.c	2013-03-01 16:38:24.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/avr-tdep.c	2013-03-10 16:44:42.116599840 +0100
861f93
@@ -1170,13 +1170,14 @@ avr_dummy_id (struct gdbarch *gdbarch, s
861f93
 
861f93
 struct stack_item
861f93
 {
861f93
-  int len;
861f93
+  ssize_t len;
861f93
   struct stack_item *prev;
861f93
   void *data;
861f93
 };
861f93
 
861f93
 static struct stack_item *
861f93
-push_stack_item (struct stack_item *prev, const bfd_byte *contents, int len)
861f93
+push_stack_item (struct stack_item *prev, const bfd_byte *contents,
861f93
+		 ssize_t len)
861f93
 {
861f93
   struct stack_item *si;
861f93
   si = xmalloc (sizeof (struct stack_item));
861f93
@@ -1265,12 +1266,12 @@ avr_push_dummy_call (struct gdbarch *gdb
861f93
 
861f93
   for (i = 0; i < nargs; i++)
861f93
     {
861f93
-      int last_regnum;
861f93
-      int j;
861f93
+      ssize_t last_regnum;
861f93
+      ssize_t j;
861f93
       struct value *arg = args[i];
861f93
       struct type *type = check_typedef (value_type (arg));
861f93
       const bfd_byte *contents = value_contents (arg);
861f93
-      int len = TYPE_LENGTH (type);
861f93
+      ssize_t len = TYPE_LENGTH (type);
861f93
 
861f93
       /* Calculate the potential last register needed.  */
861f93
       last_regnum = regnum - (len + (len & 1));
861f93
Index: gdb-7.5.50.20130310/gdb/bfin-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/bfin-tdep.c	2013-03-01 16:38:24.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/bfin-tdep.c	2013-03-10 16:46:27.992669964 +0100
861f93
@@ -506,7 +506,7 @@ bfin_push_dummy_call (struct gdbarch *gd
861f93
   gdb_byte buf[4];
861f93
   int i;
861f93
   long reg_r0, reg_r1, reg_r2;
861f93
-  int total_len = 0;
861f93
+  ssize_t total_len = 0;
861f93
   enum bfin_abi abi = bfin_abi (gdbarch);
861f93
   CORE_ADDR func_addr = find_function_addr (function, NULL);
861f93
 
861f93
@@ -530,7 +530,7 @@ bfin_push_dummy_call (struct gdbarch *gd
861f93
     {
861f93
       struct type *value_type = value_enclosing_type (args[i]);
861f93
       struct type *arg_type = check_typedef (value_type);
861f93
-      int container_len = (TYPE_LENGTH (value_type) + 3) & ~3;
861f93
+      ssize_t container_len = (TYPE_LENGTH (value_type) + 3) & ~3;
861f93
 
861f93
       sp -= container_len;
861f93
       write_memory (sp, value_contents_writeable (args[i]), container_len);
861f93
Index: gdb-7.5.50.20130310/gdb/cris-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/cris-tdep.c	2013-03-01 16:38:24.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/cris-tdep.c	2013-03-10 16:44:42.117599841 +0100
861f93
@@ -670,13 +670,13 @@ static CORE_ADDR cris_unwind_sp (struct
861f93
 
861f93
 struct stack_item
861f93
 {
861f93
-  int len;
861f93
+  ssize_t len;
861f93
   struct stack_item *prev;
861f93
   void *data;
861f93
 };
861f93
 
861f93
 static struct stack_item *
861f93
-push_stack_item (struct stack_item *prev, void *contents, int len)
861f93
+push_stack_item (struct stack_item *prev, void *contents, ssize_t len)
861f93
 {
861f93
   struct stack_item *si;
861f93
   si = xmalloc (sizeof (struct stack_item));
861f93
@@ -849,13 +849,13 @@ cris_push_dummy_call (struct gdbarch *gd
861f93
 
861f93
   for (argnum = 0; argnum < nargs; argnum++)
861f93
     {
861f93
-      int len;
861f93
+      ssize_t len;
861f93
       char *val;
861f93
-      int reg_demand;
861f93
-      int i;
861f93
+      ssize_t reg_demand;
861f93
+      ssize_t i;
861f93
       
861f93
-      len = TYPE_LENGTH (value_type (args[argnum]));
861f93
       val = (char *) value_contents (args[argnum]);
861f93
+      len = TYPE_LENGTH (value_type (args[argnum]));
861f93
       
861f93
       /* How may registers worth of storage do we need for this argument?  */
861f93
       reg_demand = (len / 4) + (len % 4 != 0 ? 1 : 0);
861f93
Index: gdb-7.5.50.20130310/gdb/h8300-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/h8300-tdep.c	2013-01-01 07:32:44.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/h8300-tdep.c	2013-03-10 16:44:42.118599841 +0100
861f93
@@ -640,7 +640,7 @@ h8300_push_dummy_call (struct gdbarch *g
861f93
 		       int struct_return, CORE_ADDR struct_addr)
861f93
 {
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
-  int stack_alloc = 0, stack_offset = 0;
861f93
+  LONGEST stack_alloc = 0, stack_offset = 0;
861f93
   int wordsize = BINWORD (gdbarch);
861f93
   int reg = E_ARG0_REGNUM;
861f93
   int argument;
861f93
@@ -667,11 +667,11 @@ h8300_push_dummy_call (struct gdbarch *g
861f93
     {
861f93
       struct cleanup *back_to;
861f93
       struct type *type = value_type (args[argument]);
861f93
-      int len = TYPE_LENGTH (type);
861f93
       char *contents = (char *) value_contents (args[argument]);
861f93
+      ssize_t len = TYPE_LENGTH (type);
861f93
 
861f93
       /* Pad the argument appropriately.  */
861f93
-      int padded_len = align_up (len, wordsize);
861f93
+      ssize_t padded_len = align_up (len, wordsize);
861f93
       gdb_byte *padded = xmalloc (padded_len);
861f93
       back_to = make_cleanup (xfree, padded);
861f93
 
861f93
@@ -700,7 +700,7 @@ h8300_push_dummy_call (struct gdbarch *g
861f93
 	      /* Heavens to Betsy --- it's really going in registers!
861f93
 	         Note that on the h8/300s, there are gaps between the
861f93
 	         registers in the register file.  */
861f93
-	      int offset;
861f93
+	      ssize_t offset;
861f93
 
861f93
 	      for (offset = 0; offset < padded_len; offset += wordsize)
861f93
 		{
861f93
Index: gdb-7.5.50.20130310/gdb/hppa-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/hppa-tdep.c	2013-03-01 16:38:24.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/hppa-tdep.c	2013-03-10 16:44:42.119599842 +0100
861f93
@@ -961,7 +961,7 @@ hppa64_push_dummy_call (struct gdbarch *
861f93
     {
861f93
       struct value *arg = args[i];
861f93
       struct type *type = value_type (arg);
861f93
-      int len = TYPE_LENGTH (type);
861f93
+      LONGEST len = TYPE_LENGTH (type);
861f93
       const bfd_byte *valbuf;
861f93
       bfd_byte fptrbuf[8];
861f93
       int regnum;
861f93
@@ -1156,7 +1156,7 @@ hppa64_return_value (struct gdbarch *gdb
861f93
 		     struct type *type, struct regcache *regcache,
861f93
 		     gdb_byte *readbuf, const gdb_byte *writebuf)
861f93
 {
861f93
-  int len = TYPE_LENGTH (type);
861f93
+  LONGEST len = TYPE_LENGTH (type);
861f93
   int regnum, offset;
861f93
 
861f93
   if (len > 16)
861f93
Index: gdb-7.5.50.20130310/gdb/i386-darwin-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/i386-darwin-tdep.c	2013-02-12 20:03:54.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/i386-darwin-tdep.c	2013-03-10 16:44:42.119599842 +0100
861f93
@@ -166,7 +166,7 @@ i386_darwin_push_dummy_call (struct gdba
861f93
 
861f93
   for (write_pass = 0; write_pass < 2; write_pass++)
861f93
     {
861f93
-      int args_space = 0;
861f93
+      LONGEST args_space = 0;
861f93
       int num_m128 = 0;
861f93
 
861f93
       if (struct_return)
861f93
Index: gdb-7.5.50.20130310/gdb/i386-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/i386-tdep.c	2013-03-10 16:16:23.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/i386-tdep.c	2013-03-10 16:44:42.120599842 +0100
861f93
@@ -2407,7 +2407,7 @@ i386_push_dummy_call (struct gdbarch *gd
861f93
   gdb_byte buf[4];
861f93
   int i;
861f93
   int write_pass;
861f93
-  int args_space = 0;
861f93
+  LONGEST args_space = 0;
861f93
 
861f93
   /* Determine the total space required for arguments and struct
861f93
      return address in a first pass (allowing for 16-byte-aligned
861f93
@@ -2415,7 +2415,7 @@ i386_push_dummy_call (struct gdbarch *gd
861f93
 
861f93
   for (write_pass = 0; write_pass < 2; write_pass++)
861f93
     {
861f93
-      int args_space_used = 0;
861f93
+      LONGEST args_space_used = 0;
861f93
 
861f93
       if (struct_return)
861f93
 	{
861f93
@@ -2432,7 +2432,7 @@ i386_push_dummy_call (struct gdbarch *gd
861f93
 
861f93
       for (i = 0; i < nargs; i++)
861f93
 	{
861f93
-	  int len = TYPE_LENGTH (value_enclosing_type (args[i]));
861f93
+	  LONGEST len = TYPE_LENGTH (value_enclosing_type (args[i]));
861f93
 
861f93
 	  if (write_pass)
861f93
 	    {
861f93
@@ -2639,7 +2639,7 @@ i386_reg_struct_return_p (struct gdbarch
861f93
 {
861f93
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
861f93
   enum type_code code = TYPE_CODE (type);
861f93
-  int len = TYPE_LENGTH (type);
861f93
+  LONGEST len = TYPE_LENGTH (type);
861f93
 
861f93
   gdb_assert (code == TYPE_CODE_STRUCT
861f93
               || code == TYPE_CODE_UNION
861f93
@@ -3094,7 +3094,7 @@ static int
861f93
 i386_convert_register_p (struct gdbarch *gdbarch,
861f93
 			 int regnum, struct type *type)
861f93
 {
861f93
-  int len = TYPE_LENGTH (type);
861f93
+  LONGEST len = TYPE_LENGTH (type);
861f93
 
861f93
   /* Values may be spread across multiple registers.  Most debugging
861f93
      formats aren't expressive enough to specify the locations, so
861f93
@@ -3127,7 +3127,7 @@ i386_register_to_value (struct frame_inf
861f93
 			int *optimizedp, int *unavailablep)
861f93
 {
861f93
   struct gdbarch *gdbarch = get_frame_arch (frame);
861f93
-  int len = TYPE_LENGTH (type);
861f93
+  LONGEST len = TYPE_LENGTH (type);
861f93
 
861f93
   if (i386_fp_regnum_p (gdbarch, regnum))
861f93
     return i387_register_to_value (frame, regnum, type, to,
861f93
@@ -3163,7 +3163,7 @@ static void
861f93
 i386_value_to_register (struct frame_info *frame, int regnum,
861f93
 			struct type *type, const gdb_byte *from)
861f93
 {
861f93
-  int len = TYPE_LENGTH (type);
861f93
+  LONGEST len = TYPE_LENGTH (type);
861f93
 
861f93
   if (i386_fp_regnum_p (get_frame_arch (frame), regnum))
861f93
     {
861f93
Index: gdb-7.5.50.20130310/gdb/ia64-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/ia64-tdep.c	2013-03-10 16:16:23.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/ia64-tdep.c	2013-03-10 16:44:42.121599843 +0100
861f93
@@ -3974,8 +3974,10 @@ ia64_push_dummy_call (struct gdbarch *gd
861f93
   int argno;
861f93
   struct value *arg;
861f93
   struct type *type;
861f93
-  int len, argoffset;
861f93
-  int nslots, rseslots, memslots, slotnum, nfuncargs;
861f93
+  LONGEST argoffset;
861f93
+  LONGEST len;
861f93
+  int rseslots, slotnum, nfuncargs;
861f93
+  LONGEST nslots, memslots;
861f93
   int floatreg;
861f93
   ULONGEST bsp;
861f93
   CORE_ADDR funcdescaddr, pc, global_pointer;
861f93
Index: gdb-7.5.50.20130310/gdb/iq2000-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/iq2000-tdep.c	2013-03-01 16:38:25.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/iq2000-tdep.c	2013-03-10 16:44:42.121599843 +0100
861f93
@@ -654,8 +654,9 @@ iq2000_push_dummy_call (struct gdbarch *
861f93
   const bfd_byte *val;
861f93
   bfd_byte buf[4];
861f93
   struct type *type;
861f93
-  int i, argreg, typelen, slacklen;
861f93
-  int stackspace = 0;
861f93
+  int i, argreg, slacklen;
861f93
+  LONGEST typelen;
861f93
+  LONGEST stackspace = 0;
861f93
   /* Used to copy struct arguments into the stack.  */
861f93
   CORE_ADDR struct_ptr;
861f93
 
861f93
Index: gdb-7.5.50.20130310/gdb/m32r-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/m32r-tdep.c	2013-01-01 07:32:46.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/m32r-tdep.c	2013-03-10 16:44:42.121599843 +0100
861f93
@@ -695,7 +695,7 @@ m32r_push_dummy_call (struct gdbarch *gd
861f93
   CORE_ADDR regval;
861f93
   gdb_byte *val;
861f93
   gdb_byte valbuf[MAX_REGISTER_SIZE];
861f93
-  int len;
861f93
+  LONGEST len;
861f93
 
861f93
   /* First force sp to a 4-byte alignment.  */
861f93
   sp = sp & ~3;
861f93
Index: gdb-7.5.50.20130310/gdb/m68k-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/m68k-tdep.c	2013-01-01 07:32:46.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/m68k-tdep.c	2013-03-10 16:44:42.121599843 +0100
861f93
@@ -384,7 +384,7 @@ m68k_reg_struct_return_p (struct gdbarch
861f93
 {
861f93
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
861f93
   enum type_code code = TYPE_CODE (type);
861f93
-  int len = TYPE_LENGTH (type);
861f93
+  LONGEST len = TYPE_LENGTH (type);
861f93
 
861f93
   gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
861f93
 	      || code == TYPE_CODE_COMPLEX);
861f93
@@ -516,9 +516,9 @@ m68k_push_dummy_call (struct gdbarch *gd
861f93
   for (i = nargs - 1; i >= 0; i--)
861f93
     {
861f93
       struct type *value_type = value_enclosing_type (args[i]);
861f93
-      int len = TYPE_LENGTH (value_type);
861f93
-      int container_len = (len + 3) & ~3;
861f93
-      int offset;
861f93
+      LONGEST len = TYPE_LENGTH (value_type);
861f93
+      LONGEST container_len = (len + 3) & ~3;
861f93
+      LONGEST offset;
861f93
 
861f93
       /* Non-scalars bigger than 4 bytes are left aligned, others are
861f93
 	 right aligned.  */
861f93
Index: gdb-7.5.50.20130310/gdb/m88k-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/m88k-tdep.c	2013-01-01 07:32:47.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/m88k-tdep.c	2013-03-10 16:44:42.121599843 +0100
861f93
@@ -260,13 +260,13 @@ m88k_store_arguments (struct regcache *r
861f93
 {
861f93
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
861f93
   int num_register_words = 0;
861f93
-  int num_stack_words = 0;
861f93
+  LONGEST num_stack_words = 0;
861f93
   int i;
861f93
 
861f93
   for (i = 0; i < nargs; i++)
861f93
     {
861f93
       struct type *type = value_type (args[i]);
861f93
-      int len = TYPE_LENGTH (type);
861f93
+      LONGEST len = TYPE_LENGTH (type);
861f93
 
861f93
       if (m88k_integral_or_pointer_p (type) && len < 4)
861f93
 	{
861f93
@@ -308,8 +308,8 @@ m88k_store_arguments (struct regcache *r
861f93
     {
861f93
       const bfd_byte *valbuf = value_contents (args[i]);
861f93
       struct type *type = value_type (args[i]);
861f93
-      int len = TYPE_LENGTH (type);
861f93
-      int stack_word = num_stack_words;
861f93
+      LONGEST len = TYPE_LENGTH (type);
861f93
+      LONGEST stack_word = num_stack_words;
861f93
 
861f93
       if (m88k_in_register_p (type))
861f93
 	{
861f93
Index: gdb-7.5.50.20130310/gdb/mep-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/mep-tdep.c	2013-03-01 16:38:25.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/mep-tdep.c	2013-03-10 16:44:42.122599843 +0100
861f93
@@ -2279,7 +2279,7 @@ push_large_arguments (CORE_ADDR sp, int
861f93
 
861f93
   for (i = 0; i < argc; i++)
861f93
     {
861f93
-      unsigned arg_len = TYPE_LENGTH (value_type (argv[i]));
861f93
+      ULONGEST arg_len = TYPE_LENGTH (value_type (argv[i]));
861f93
 
861f93
       if (arg_len > MEP_GPR_SIZE)
861f93
         {
861f93
Index: gdb-7.5.50.20130310/gdb/mips-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/mips-tdep.c	2013-02-24 13:54:04.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/mips-tdep.c	2013-03-10 16:44:42.123599844 +0100
861f93
@@ -396,7 +396,7 @@ static void
861f93
 mips_xfer_register (struct gdbarch *gdbarch, struct regcache *regcache,
861f93
 		    int reg_num, int length,
861f93
 		    enum bfd_endian endian, gdb_byte *in,
861f93
-		    const gdb_byte *out, int buf_offset)
861f93
+		    const gdb_byte *out, LONGEST buf_offset)
861f93
 {
861f93
   int reg_offset = 0;
861f93
 
861f93
@@ -419,8 +419,8 @@ mips_xfer_register (struct gdbarch *gdba
861f93
     }
861f93
   if (mips_debug)
861f93
     fprintf_unfiltered (gdb_stderr,
861f93
-			"xfer $%d, reg offset %d, buf offset %d, length %d, ",
861f93
-			reg_num, reg_offset, buf_offset, length);
861f93
+			"xfer $%d, reg offset %d, buf offset %s, length %d, ",
861f93
+			reg_num, reg_offset, plongest (buf_offset), length);
861f93
   if (mips_debug && out != NULL)
861f93
     {
861f93
       int i;
861f93
@@ -4346,13 +4346,13 @@ mips_eabi_push_dummy_call (struct gdbarc
861f93
       gdb_byte valbuf[MAX_REGISTER_SIZE];
861f93
       struct value *arg = args[argnum];
861f93
       struct type *arg_type = check_typedef (value_type (arg));
861f93
-      int len = TYPE_LENGTH (arg_type);
861f93
+      LONGEST len = TYPE_LENGTH (arg_type);
861f93
       enum type_code typecode = TYPE_CODE (arg_type);
861f93
 
861f93
       if (mips_debug)
861f93
 	fprintf_unfiltered (gdb_stdlog,
861f93
-			    "mips_eabi_push_dummy_call: %d len=%d type=%d",
861f93
-			    argnum + 1, len, (int) typecode);
861f93
+			    "mips_eabi_push_dummy_call: %d len=%s type=%d",
861f93
+			    argnum + 1, plongest (len), (int) typecode);
861f93
 
861f93
       /* Function pointer arguments to mips16 code need to be made into
861f93
          mips16 pointers.  */
861f93
@@ -4637,7 +4637,7 @@ mips_eabi_return_value (struct gdbarch *
861f93
 
861f93
 static int
861f93
 mips_n32n64_fp_arg_chunk_p (struct gdbarch *gdbarch, struct type *arg_type,
861f93
-			    int offset)
861f93
+			    LONGEST offset)
861f93
 {
861f93
   int i;
861f93
 
861f93
@@ -4652,7 +4652,7 @@ mips_n32n64_fp_arg_chunk_p (struct gdbar
861f93
 
861f93
   for (i = 0; i < TYPE_NFIELDS (arg_type); i++)
861f93
     {
861f93
-      int pos;
861f93
+      LONGEST pos;
861f93
       struct type *field_type;
861f93
 
861f93
       /* We're only looking at normal fields.  */
861f93
@@ -4694,7 +4694,7 @@ mips_n32n64_push_dummy_call (struct gdba
861f93
   int argreg;
861f93
   int float_argreg;
861f93
   int argnum;
861f93
-  int len = 0;
861f93
+  LONGEST len = 0;
861f93
   int stack_offset = 0;
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   CORE_ADDR func_addr = find_function_addr (function, NULL);
861f93
@@ -5045,11 +5045,11 @@ mips_n32n64_return_value (struct gdbarch
861f93
 				: MIPS_V0_REGNUM);
861f93
 	   field < TYPE_NFIELDS (type); field++, regnum += 2)
861f93
 	{
861f93
-	  int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
861f93
-			/ TARGET_CHAR_BIT);
861f93
+	  LONGEST offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
861f93
+			    / TARGET_CHAR_BIT);
861f93
 	  if (mips_debug)
861f93
-	    fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n",
861f93
-				offset);
861f93
+	    fprintf_unfiltered (gdb_stderr, "Return float struct+%s\n",
861f93
+				plongest (offset));
861f93
 	  if (TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)) == 16)
861f93
 	    {
861f93
 	      /* A 16-byte long double field goes in two consecutive
861f93
@@ -5091,8 +5091,8 @@ mips_n32n64_return_value (struct gdbarch
861f93
 	  if (offset + xfer > TYPE_LENGTH (type))
861f93
 	    xfer = TYPE_LENGTH (type) - offset;
861f93
 	  if (mips_debug)
861f93
-	    fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
861f93
-				offset, xfer, regnum);
861f93
+	    fprintf_unfiltered (gdb_stderr, "Return struct+%s:%d in $%d\n",
861f93
+				plongest (offset), xfer, regnum);
861f93
 	  mips_xfer_register (gdbarch, regcache,
861f93
 			      gdbarch_num_regs (gdbarch) + regnum,
861f93
 			      xfer, BFD_ENDIAN_UNKNOWN, readbuf, writebuf,
861f93
@@ -5150,7 +5150,7 @@ mips_o32_push_dummy_call (struct gdbarch
861f93
   int argreg;
861f93
   int float_argreg;
861f93
   int argnum;
861f93
-  int len = 0;
861f93
+  LONGEST len = 0;
861f93
   int stack_offset = 0;
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   CORE_ADDR func_addr = find_function_addr (function, NULL);
861f93
@@ -5214,13 +5214,13 @@ mips_o32_push_dummy_call (struct gdbarch
861f93
       const gdb_byte *val;
861f93
       struct value *arg = args[argnum];
861f93
       struct type *arg_type = check_typedef (value_type (arg));
861f93
-      int len = TYPE_LENGTH (arg_type);
861f93
+      LONGEST len = TYPE_LENGTH (arg_type);
861f93
       enum type_code typecode = TYPE_CODE (arg_type);
861f93
 
861f93
       if (mips_debug)
861f93
 	fprintf_unfiltered (gdb_stdlog,
861f93
-			    "mips_o32_push_dummy_call: %d len=%d type=%d",
861f93
-			    argnum + 1, len, (int) typecode);
861f93
+			    "mips_o32_push_dummy_call: %d len=%s type=%d",
861f93
+			    argnum + 1, plongest (len), (int) typecode);
861f93
 
861f93
       val = value_contents (arg);
861f93
 
861f93
@@ -5678,8 +5678,8 @@ mips_o64_push_dummy_call (struct gdbarch
861f93
   int argreg;
861f93
   int float_argreg;
861f93
   int argnum;
861f93
-  int len = 0;
861f93
-  int stack_offset = 0;
861f93
+  LONGEST len = 0;
861f93
+  LONGEST stack_offset = 0;
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   CORE_ADDR func_addr = find_function_addr (function, NULL);
861f93
 
861f93
@@ -5740,13 +5740,13 @@ mips_o64_push_dummy_call (struct gdbarch
861f93
       gdb_byte valbuf[MAX_REGISTER_SIZE];
861f93
       struct value *arg = args[argnum];
861f93
       struct type *arg_type = check_typedef (value_type (arg));
861f93
-      int len = TYPE_LENGTH (arg_type);
861f93
+      LONGEST len = TYPE_LENGTH (arg_type);
861f93
       enum type_code typecode = TYPE_CODE (arg_type);
861f93
 
861f93
       if (mips_debug)
861f93
 	fprintf_unfiltered (gdb_stdlog,
861f93
-			    "mips_o64_push_dummy_call: %d len=%d type=%d",
861f93
-			    argnum + 1, len, (int) typecode);
861f93
+			    "mips_o64_push_dummy_call: %d len=%s type=%d",
861f93
+			    argnum + 1, plongest (len), (int) typecode);
861f93
 
861f93
       val = value_contents (arg);
861f93
 
861f93
Index: gdb-7.5.50.20130310/gdb/mn10300-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/mn10300-tdep.c	2013-03-01 16:38:25.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/mn10300-tdep.c	2013-03-10 16:44:42.123599844 +0100
861f93
@@ -1228,7 +1228,7 @@ mn10300_push_dummy_call (struct gdbarch
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   const int push_size = register_size (gdbarch, E_PC_REGNUM);
861f93
   int regs_used;
861f93
-  int len, arg_len; 
861f93
+  LONGEST len, arg_len;
861f93
   int stack_offset = 0;
861f93
   int argnum;
861f93
   char *val, valbuf[MAX_REGISTER_SIZE];
861f93
Index: gdb-7.5.50.20130310/gdb/mt-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/mt-tdep.c	2013-01-01 07:32:47.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/mt-tdep.c	2013-03-10 16:44:42.124599844 +0100
861f93
@@ -783,9 +783,9 @@ mt_push_dummy_call (struct gdbarch *gdba
861f93
   gdb_byte buf[MT_MAX_STRUCT_SIZE];
861f93
   int argreg = MT_1ST_ARGREG;
861f93
   int split_param_len = 0;
861f93
-  int stack_dest = sp;
861f93
+  LONGEST stack_dest = sp;
861f93
   int slacklen;
861f93
-  int typelen;
861f93
+  LONGEST typelen;
861f93
   int i, j;
861f93
 
861f93
   /* First handle however many args we can fit into MT_1ST_ARGREG thru
861f93
Index: gdb-7.5.50.20130310/gdb/ppc-sysv-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/ppc-sysv-tdep.c	2013-01-23 21:03:18.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/ppc-sysv-tdep.c	2013-03-10 16:44:42.124599844 +0100
861f93
@@ -68,7 +68,7 @@ ppc_sysv_abi_push_dummy_call (struct gdb
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   int opencl_abi = ppc_sysv_use_opencl_abi (value_type (function));
861f93
   ULONGEST saved_sp;
861f93
-  int argspace = 0;		/* 0 is an initial wrong guess.  */
861f93
+  LONGEST argspace = 0;		/* 0 is an initial wrong guess.  */
861f93
   int write_pass;
861f93
 
861f93
   gdb_assert (tdep->wordsize == 4);
861f93
@@ -99,9 +99,9 @@ ppc_sysv_abi_push_dummy_call (struct gdb
861f93
       /* Next available vector register for vector arguments.  */
861f93
       int vreg = 2;
861f93
       /* Arguments start above the "LR save word" and "Back chain".  */
861f93
-      int argoffset = 2 * tdep->wordsize;
861f93
+      LONGEST argoffset = 2 * tdep->wordsize;
861f93
       /* Structures start after the arguments.  */
861f93
-      int structoffset = argoffset + argspace;
861f93
+      LONGEST structoffset = argoffset + argspace;
861f93
 
861f93
       /* If the function is returning a `struct', then the first word
861f93
          (which will be passed in r3) is used for struct return
861f93
@@ -120,7 +120,7 @@ ppc_sysv_abi_push_dummy_call (struct gdb
861f93
 	{
861f93
 	  struct value *arg = args[argno];
861f93
 	  struct type *type = check_typedef (value_type (arg));
861f93
-	  int len = TYPE_LENGTH (type);
861f93
+	  ssize_t len = TYPE_LENGTH (type);
861f93
 	  const bfd_byte *val = value_contents (arg);
861f93
 
861f93
 	  if (TYPE_CODE (type) == TYPE_CODE_FLT && len <= 8
861f93
@@ -1556,14 +1556,14 @@ ppc64_sysv_abi_push_dummy_call (struct g
861f93
 	    }
861f93
 	  else
861f93
 	    {
861f93
-	      int byte;
861f93
+	      ssize_t byte;
861f93
 	      for (byte = 0; byte < TYPE_LENGTH (type);
861f93
 		   byte += tdep->wordsize)
861f93
 		{
861f93
 		  if (write_pass && greg <= 10)
861f93
 		    {
861f93
 		      gdb_byte regval[MAX_REGISTER_SIZE];
861f93
-		      int len = TYPE_LENGTH (type) - byte;
861f93
+		      ssize_t len = TYPE_LENGTH (type) - byte;
861f93
 		      if (len > tdep->wordsize)
861f93
 			len = tdep->wordsize;
861f93
 		      memset (regval, 0, sizeof regval);
861f93
@@ -1591,7 +1591,7 @@ ppc64_sysv_abi_push_dummy_call (struct g
861f93
 		     register.  Work around this by always writing the
861f93
 		     value to memory.  Fortunately, doing this
861f93
 		     simplifies the code.  */
861f93
-		  int len = TYPE_LENGTH (type);
861f93
+		  ssize_t len = TYPE_LENGTH (type);
861f93
 		  if (len < tdep->wordsize)
861f93
 		    write_memory (gparam + tdep->wordsize - len, val, len);
861f93
 		  else
861f93
Index: gdb-7.5.50.20130310/gdb/rl78-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/rl78-tdep.c	2013-01-01 07:32:50.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/rl78-tdep.c	2013-03-10 16:44:42.124599844 +0100
861f93
@@ -1019,8 +1019,8 @@ rl78_push_dummy_call (struct gdbarch *gd
861f93
   for (i = nargs - 1; i >= 0; i--)
861f93
     {
861f93
       struct type *value_type = value_enclosing_type (args[i]);
861f93
-      int len = TYPE_LENGTH (value_type);
861f93
-      int container_len = (len + 1) & ~1;
861f93
+      LONGEST len = TYPE_LENGTH (value_type);
861f93
+      LONGEST container_len = (len + 1) & ~1;
861f93
 
861f93
       sp -= container_len;
861f93
       write_memory (rl78_make_data_address (sp),
861f93
Index: gdb-7.5.50.20130310/gdb/rs6000-aix-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/rs6000-aix-tdep.c	2013-01-01 07:32:50.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/rs6000-aix-tdep.c	2013-03-10 16:44:42.125599845 +0100
861f93
@@ -198,9 +198,9 @@ rs6000_push_dummy_call (struct gdbarch *
861f93
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   int ii;
861f93
-  int len = 0;
861f93
+  LONGEST len = 0;
861f93
   int argno;			/* current argument number */
861f93
-  int argbytes;			/* current argument byte */
861f93
+  LONGEST argbytes;		/* current argument byte */
861f93
   gdb_byte tmp_buffer[50];
861f93
   int f_argno = 0;		/* current floating point argno */
861f93
   int wordsize = gdbarch_tdep (gdbarch)->wordsize;
861f93
@@ -328,7 +328,7 @@ ran_out_of_registers_for_arguments:
861f93
 
861f93
   if ((argno < nargs) || argbytes)
861f93
     {
861f93
-      int space = 0, jj;
861f93
+      LONGEST space = 0, jj;
861f93
 
861f93
       if (argbytes)
861f93
 	{
861f93
Index: gdb-7.5.50.20130310/gdb/s390-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/s390-tdep.c	2013-01-01 07:32:50.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/s390-tdep.c	2013-03-10 16:44:42.125599845 +0100
861f93
@@ -2482,7 +2482,7 @@ is_float_like (struct type *type)
861f93
 
861f93
 
861f93
 static int
861f93
-is_power_of_two (unsigned int n)
861f93
+is_power_of_two (ULONGEST n)
861f93
 {
861f93
   return ((n & (n - 1)) == 0);
861f93
 }
861f93
@@ -2668,7 +2668,7 @@ s390_push_dummy_call (struct gdbarch *gd
861f93
       {
861f93
         struct value *arg = args[i];
861f93
         struct type *type = check_typedef (value_type (arg));
861f93
-        unsigned length = TYPE_LENGTH (type);
861f93
+        ULONGEST length = TYPE_LENGTH (type);
861f93
 
861f93
 	if (s390_function_arg_pass_by_reference (type))
861f93
 	  {
861f93
Index: gdb-7.5.50.20130310/gdb/score-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/score-tdep.c	2013-03-01 16:38:26.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/score-tdep.c	2013-03-10 16:44:42.125599845 +0100
861f93
@@ -515,7 +515,7 @@ score_push_dummy_call (struct gdbarch *g
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   int argnum;
861f93
   int argreg;
861f93
-  int arglen = 0;
861f93
+  LONGEST arglen = 0;
861f93
   CORE_ADDR stack_offset = 0;
861f93
   CORE_ADDR addr = 0;
861f93
 
861f93
Index: gdb-7.5.50.20130310/gdb/sh-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/sh-tdep.c	2013-01-01 07:32:50.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/sh-tdep.c	2013-03-10 16:44:42.126599845 +0100
861f93
@@ -807,7 +807,7 @@ sh_skip_prologue (struct gdbarch *gdbarc
861f93
 static int
861f93
 sh_use_struct_convention (int renesas_abi, struct type *type)
861f93
 {
861f93
-  int len = TYPE_LENGTH (type);
861f93
+  LONGEST len = TYPE_LENGTH (type);
861f93
   int nelem = TYPE_NFIELDS (type);
861f93
 
861f93
   /* The Renesas ABI returns aggregate types always on stack.  */
861f93
@@ -909,7 +909,7 @@ sh_frame_align (struct gdbarch *ignore,
861f93
 
861f93
 /* Helper function to justify value in register according to endianess.  */
861f93
 static char *
861f93
-sh_justify_value_in_reg (struct gdbarch *gdbarch, struct value *val, int len)
861f93
+sh_justify_value_in_reg (struct gdbarch *gdbarch, struct value *val, LONGEST len)
861f93
 {
861f93
   static char valbuf[4];
861f93
 
861f93
@@ -1069,7 +1069,8 @@ sh_push_dummy_call_fpu (struct gdbarch *
861f93
   struct type *type;
861f93
   CORE_ADDR regval;
861f93
   char *val;
861f93
-  int len, reg_size = 0;
861f93
+  LONGEST len;
861f93
+  ssize_t reg_size = 0;
861f93
   int pass_on_stack = 0;
861f93
   int treat_as_flt;
861f93
   int last_reg_arg = INT_MAX;
861f93
@@ -1210,7 +1211,8 @@ sh_push_dummy_call_nofpu (struct gdbarch
861f93
   struct type *type;
861f93
   CORE_ADDR regval;
861f93
   char *val;
861f93
-  int len, reg_size = 0;
861f93
+  LONGEST len;
861f93
+  ssize_t reg_size = 0;
861f93
   int pass_on_stack = 0;
861f93
   int last_reg_arg = INT_MAX;
861f93
 
861f93
Index: gdb-7.5.50.20130310/gdb/sh64-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/sh64-tdep.c	2013-03-01 16:38:26.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/sh64-tdep.c	2013-03-10 16:44:42.126599845 +0100
861f93
@@ -1058,7 +1058,7 @@ sh64_push_dummy_call (struct gdbarch *gd
861f93
 		      CORE_ADDR struct_addr)
861f93
 {
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
-  int stack_offset, stack_alloc;
861f93
+  LONGEST stack_offset, stack_alloc;
861f93
   int int_argreg;
861f93
   int float_argreg;
861f93
   int double_argreg;
861f93
@@ -1069,7 +1069,7 @@ sh64_push_dummy_call (struct gdbarch *gd
861f93
   CORE_ADDR regval;
861f93
   char *val;
861f93
   char valbuf[8];
861f93
-  int len;
861f93
+  LONGEST len;
861f93
   int argreg_size;
861f93
   int fp_args[12];
861f93
 
861f93
Index: gdb-7.5.50.20130310/gdb/sparc-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/sparc-tdep.c	2013-03-10 16:44:33.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/sparc-tdep.c	2013-03-10 16:44:42.127599846 +0100
861f93
@@ -471,7 +471,7 @@ sparc32_store_arguments (struct regcache
861f93
   for (i = 0; i < nargs; i++)
861f93
     {
861f93
       struct type *type = value_type (args[i]);
861f93
-      int len = TYPE_LENGTH (type);
861f93
+      LONGEST len = TYPE_LENGTH (type);
861f93
 
861f93
       if (sparc_structure_or_union_p (type)
861f93
 	  || (sparc_floating_p (type) && len == 16)
861f93
Index: gdb-7.5.50.20130310/gdb/sparc64-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/sparc64-tdep.c	2013-01-01 07:32:51.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/sparc64-tdep.c	2013-03-10 16:44:42.127599846 +0100
861f93
@@ -639,7 +639,8 @@ sparc64_16_byte_align_p (struct type *ty
861f93
 
861f93
 static void
861f93
 sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
861f93
-			       const gdb_byte *valbuf, int element, int bitpos)
861f93
+			       const gdb_byte *valbuf, int element,
861f93
+			       LONGEST bitpos)
861f93
 {
861f93
   int len = TYPE_LENGTH (type);
861f93
 
861f93
@@ -681,7 +682,7 @@ sparc64_store_floating_fields (struct re
861f93
       for (i = 0; i < TYPE_NFIELDS (type); i++)
861f93
 	{
861f93
 	  struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
861f93
-	  int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
861f93
+	  LONGEST subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
861f93
 
861f93
 	  sparc64_store_floating_fields (regcache, subtype, valbuf,
861f93
 					 element, subpos);
861f93
@@ -713,7 +714,7 @@ sparc64_store_floating_fields (struct re
861f93
 
861f93
 static void
861f93
 sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
861f93
-				 gdb_byte *valbuf, int bitpos)
861f93
+				 gdb_byte *valbuf, LONGEST bitpos)
861f93
 {
861f93
   if (sparc64_floating_p (type))
861f93
     {
861f93
@@ -750,7 +751,7 @@ sparc64_extract_floating_fields (struct
861f93
       for (i = 0; i < TYPE_NFIELDS (type); i++)
861f93
 	{
861f93
 	  struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
861f93
-	  int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
861f93
+	  LONGEST subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
861f93
 
861f93
 	  sparc64_extract_floating_fields (regcache, subtype, valbuf, subpos);
861f93
 	}
861f93
@@ -783,7 +784,7 @@ sparc64_store_arguments (struct regcache
861f93
   for (i = 0; i < nargs; i++)
861f93
     {
861f93
       struct type *type = value_type (args[i]);
861f93
-      int len = TYPE_LENGTH (type);
861f93
+      LONGEST len = TYPE_LENGTH (type);
861f93
 
861f93
       if (sparc64_structure_or_union_p (type)
861f93
 	  || (sparc64_complex_floating_p (type) && len == 32))
861f93
@@ -883,7 +884,7 @@ sparc64_store_arguments (struct regcache
861f93
     {
861f93
       const gdb_byte *valbuf = value_contents (args[i]);
861f93
       struct type *type = value_type (args[i]);
861f93
-      int len = TYPE_LENGTH (type);
861f93
+      LONGEST len = TYPE_LENGTH (type);
861f93
       int regnum = -1;
861f93
       gdb_byte buf[16];
861f93
 
861f93
Index: gdb-7.5.50.20130310/gdb/spu-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/spu-tdep.c	2013-01-01 07:32:51.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/spu-tdep.c	2013-03-10 16:44:42.127599846 +0100
861f93
@@ -1373,7 +1373,7 @@ spu_push_dummy_call (struct gdbarch *gdb
861f93
       struct value *arg = args[i];
861f93
       struct type *type = check_typedef (value_type (arg));
861f93
       const gdb_byte *contents = value_contents (arg);
861f93
-      int n_regs = align_up (TYPE_LENGTH (type), 16) / 16;
861f93
+      LONGEST n_regs = align_up (TYPE_LENGTH (type), 16) / 16;
861f93
 
861f93
       /* If the argument doesn't wholly fit into registers, it and
861f93
 	 all subsequent arguments go to the stack.  */
861f93
@@ -1405,7 +1405,7 @@ spu_push_dummy_call (struct gdbarch *gdb
861f93
 	{
861f93
 	  struct value *arg = args[i];
861f93
 	  struct type *type = check_typedef (value_type (arg));
861f93
-	  int len = TYPE_LENGTH (type);
861f93
+	  LONGEST len = TYPE_LENGTH (type);
861f93
 	  int preferred_slot;
861f93
 	  
861f93
 	  if (spu_scalar_value_p (type))
861f93
Index: gdb-7.5.50.20130310/gdb/tic6x-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/tic6x-tdep.c	2013-03-01 16:38:27.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/tic6x-tdep.c	2013-03-10 16:44:42.128599846 +0100
861f93
@@ -896,7 +896,7 @@ tic6x_push_dummy_call (struct gdbarch *g
861f93
   int argreg = 0;
861f93
   int argnum;
861f93
   int stack_offset = 4;
861f93
-  int references_offset = 4;
861f93
+  LONGEST references_offset = 4;
861f93
   CORE_ADDR func_addr = find_function_addr (function, NULL);
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   struct type *func_type = value_type (function);
861f93
@@ -930,7 +930,7 @@ tic6x_push_dummy_call (struct gdbarch *g
861f93
   /* Now make space on the stack for the args.  */
861f93
   for (argnum = 0; argnum < nargs; argnum++)
861f93
     {
861f93
-      int len = align_up (TYPE_LENGTH (value_type (args[argnum])), 4);
861f93
+      LONGEST len = align_up (TYPE_LENGTH (value_type (args[argnum])), 4);
861f93
       if (argnum >= 10 - argreg)
861f93
 	references_offset += len;
861f93
       stack_offset += len;
861f93
@@ -949,7 +949,7 @@ tic6x_push_dummy_call (struct gdbarch *g
861f93
       const gdb_byte *val;
861f93
       struct value *arg = args[argnum];
861f93
       struct type *arg_type = check_typedef (value_type (arg));
861f93
-      int len = TYPE_LENGTH (arg_type);
861f93
+      ssize_t len = TYPE_LENGTH (arg_type);
861f93
       enum type_code typecode = TYPE_CODE (arg_type);
861f93
 
861f93
       val = value_contents (arg);
861f93
@@ -1109,7 +1109,8 @@ tic6x_push_dummy_call (struct gdbarch *g
861f93
 	    }
861f93
 	  else
861f93
 	    internal_error (__FILE__, __LINE__,
861f93
-			    _("unexpected length %d of arg %d"), len, argnum);
861f93
+			    _("unexpected length %s of arg %d"),
861f93
+			    plongest (len), argnum);
861f93
 
861f93
 	  addr = sp + stack_offset;
861f93
 	  write_memory (addr, val, len);
861f93
Index: gdb-7.5.50.20130310/gdb/tilegx-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/tilegx-tdep.c	2013-03-02 02:34:40.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/tilegx-tdep.c	2013-03-10 16:45:31.857629100 +0100
861f93
@@ -291,7 +291,7 @@ tilegx_push_dummy_call (struct gdbarch *
861f93
   CORE_ADDR stack_dest = sp;
861f93
   int argreg = TILEGX_R0_REGNUM;
861f93
   int i, j;
861f93
-  int typelen, slacklen, alignlen;
861f93
+  LONGEST typelen, slacklen, alignlen;
861f93
   static const gdb_byte four_zero_words[16] = { 0 };
861f93
 
861f93
   /* If struct_return is 1, then the struct return address will
861f93
Index: gdb-7.5.50.20130310/gdb/v850-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/v850-tdep.c	2013-03-02 19:26:30.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/v850-tdep.c	2013-03-10 16:44:42.128599846 +0100
861f93
@@ -817,7 +817,7 @@ v850_push_dummy_call (struct gdbarch *gd
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   int argreg;
861f93
   int argnum;
861f93
-  int len = 0;
861f93
+  LONGEST len = 0;
861f93
   int stack_offset;
861f93
 
861f93
   /* The offset onto the stack at which we will start copying parameters
861f93
@@ -842,7 +842,7 @@ v850_push_dummy_call (struct gdbarch *gd
861f93
      in four registers available.  Loop thru args from first to last.  */
861f93
   for (argnum = 0; argnum < nargs; argnum++)
861f93
     {
861f93
-      int len;
861f93
+      LONGEST len;
861f93
       gdb_byte *val;
861f93
       gdb_byte valbuf[v850_reg_size];
861f93
 
861f93
Index: gdb-7.5.50.20130310/gdb/vax-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/vax-tdep.c	2013-03-10 16:44:34.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/vax-tdep.c	2013-03-10 16:44:42.128599846 +0100
861f93
@@ -115,7 +115,7 @@ vax_store_arguments (struct regcache *re
861f93
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   gdb_byte buf[4];
861f93
-  int count = 0;
861f93
+  LONGEST count = 0;
861f93
   int i;
861f93
 
861f93
   /* We create an argument list on the stack, and make the argument
861f93
@@ -124,7 +124,7 @@ vax_store_arguments (struct regcache *re
861f93
   /* Push arguments in reverse order.  */
861f93
   for (i = nargs - 1; i >= 0; i--)
861f93
     {
861f93
-      int len = TYPE_LENGTH (value_enclosing_type (args[i]));
861f93
+      LONGEST len = TYPE_LENGTH (value_enclosing_type (args[i]));
861f93
 
861f93
       sp -= (len + 3) & ~3;
861f93
       count += (len + 3) / 4;
861f93
Index: gdb-7.5.50.20130310/gdb/xstormy16-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/xstormy16-tdep.c	2013-03-01 16:38:27.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/xstormy16-tdep.c	2013-03-10 16:46:05.888653201 +0100
861f93
@@ -235,8 +235,9 @@ xstormy16_push_dummy_call (struct gdbarc
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   CORE_ADDR stack_dest = sp;
861f93
   int argreg = E_1ST_ARG_REGNUM;
861f93
-  int i, j;
861f93
-  int typelen, slacklen;
861f93
+  int i, slacklen;
861f93
+  LONGEST j;
861f93
+  LONGEST typelen;
861f93
   const gdb_byte *val;
861f93
   gdb_byte buf[xstormy16_pc_size];
861f93
 
861f93
Index: gdb-7.5.50.20130310/gdb/xtensa-tdep.c
861f93
===================================================================
861f93
--- gdb-7.5.50.20130310.orig/gdb/xtensa-tdep.c	2013-01-01 07:41:29.000000000 +0100
861f93
+++ gdb-7.5.50.20130310/gdb/xtensa-tdep.c	2013-03-10 16:44:42.129599847 +0100
861f93
@@ -1653,8 +1653,7 @@ xtensa_store_return_value (struct type *
861f93
 
861f93
       if (len > (callsize > 8 ? 8 : 16))
861f93
 	internal_error (__FILE__, __LINE__,
861f93
-			_("unimplemented for this length: %d"),
861f93
-			TYPE_LENGTH (type));
861f93
+			_("unimplemented for this length: %d"), len);
861f93
       areg = arreg_number (gdbarch,
861f93
 			   gdbarch_tdep (gdbarch)->a0_base + 2 + callsize, wb);
861f93
 
861f93
@@ -1728,18 +1727,18 @@ xtensa_push_dummy_call (struct gdbarch *
861f93
 {
861f93
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861f93
   int i;
861f93
-  int size, onstack_size;
861f93
+  LONGEST size, onstack_size;
861f93
   gdb_byte *buf = (gdb_byte *) alloca (16);
861f93
   CORE_ADDR ra, ps;
861f93
   struct argument_info
861f93
   {
861f93
     const bfd_byte *contents;
861f93
-    int length;
861f93
+    ssize_t length;
861f93
     int onstack;		/* onstack == 0 => in reg */
861f93
     int align;			/* alignment */
861f93
     union
861f93
     {
861f93
-      int offset;		/* stack offset if on stack.  */
861f93
+      ssize_t offset;		/* stack offset if on stack.  */
861f93
       int regno;		/* regno if in register.  */
861f93
     } u;
861f93
   };
861f93
@@ -1763,9 +1762,10 @@ xtensa_push_dummy_call (struct gdbarch *
861f93
         {
861f93
 	  struct value *arg = args[i];
861f93
 	  struct type *arg_type = check_typedef (value_type (arg));
861f93
-	  fprintf_unfiltered (gdb_stdlog, "%2d: %s %3d ", i,
861f93
-			      host_address_to_string (arg),
861f93
-			      TYPE_LENGTH (arg_type));
861f93
+	  const char *arg_type_len_s = pulongest (TYPE_LENGTH (arg_type));
861f93
+
861f93
+	  fprintf_unfiltered (gdb_stdlog, "%2d: %s %s ", i,
861f93
+			      host_address_to_string (arg), arg_type_len_s);
861f93
 	  switch (TYPE_CODE (arg_type))
861f93
 	    {
861f93
 	    case TYPE_CODE_INT:
861f93
@@ -1835,8 +1835,8 @@ xtensa_push_dummy_call (struct gdbarch *
861f93
 	  info->align = TYPE_LENGTH (builtin_type (gdbarch)->builtin_long);
861f93
 	  break;
861f93
 	}
861f93
-      info->length = TYPE_LENGTH (arg_type);
861f93
       info->contents = value_contents (arg);
861f93
+      info->length = TYPE_LENGTH (arg_type);
861f93
 
861f93
       /* Align size and onstack_size.  */
861f93
       size = (size + info->align - 1) & ~(info->align - 1);
861f93
@@ -1881,7 +1881,7 @@ xtensa_push_dummy_call (struct gdbarch *
861f93
 
861f93
       if (info->onstack)
861f93
 	{
861f93
-	  int n = info->length;
861f93
+	  ssize_t n = info->length;
861f93
 	  CORE_ADDR offset = sp + info->u.offset;
861f93
 
861f93
 	  /* Odd-sized structs are aligned to the lower side of a memory
861f93
@@ -1897,7 +1897,7 @@ xtensa_push_dummy_call (struct gdbarch *
861f93
 	}
861f93
       else
861f93
 	{
861f93
-	  int n = info->length;
861f93
+	  ssize_t n = info->length;
861f93
 	  const bfd_byte *cp = info->contents;
861f93
 	  int r = info->u.regno;
861f93