This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [PATCH v2] Expand bitpos and type.length to LONGEST and ULONGEST


Hi Siddhesh,

while I have a local patch for it it is easier to state that:
 * the patch needs a small rebase to HEAD for very recent changes.
 * it does not compile on 32-bit i386 host OS due to %ld used for LONGEST.


On Fri, 04 May 2012 15:08:58 +0200, Siddhesh Poyarekar wrote:
> I have finally finished this off with a combined patch to expand bitpos
> to LONGEST and type.length to ULONGEST.

Therefore:
> -	int bitpos;
> +	LONGEST bitpos;
+
> -  unsigned length;
> +  ULONGEST length;


> This however is not possible anyway, since bitpos may be negative for
> vtable offsets and as a result, I have extended bitpos to LONGEST in
> this patch.

In such case I think we can keep signedness for all the changes.  While one
may consider more clean to use unsigned types in some cases it can bring
unexpected regressions, for example in amd64_push_arguments you correctly
changed the first occurence:

> -      int len = TYPE_LENGTH (type);
> +      LONGEST len = TYPE_LENGTH (type);

But in other cases you use ULONGEST.  In this case ULONGEST would be
a regression as there is below:

          for (j = 0; len > 0; j++, len -= 8)

If you have carefully checked all the signedness changes for possible
regressions I will re-review it.  Still it seems to me unrelated to this patch
(and possibly not worth the effort, YMMV).
Or did you see some specific splint warnings for it?
I have marked in this patch such lines by ^X$.
I understand changing to patch to keep the signedness looks like worsening the
patch.

I am sorry this misunderstanding happened, if it was cleared up in advanced it
would save a lot of work.

If you would like to do some signedness cleanups it should be posted as
a separate patch for review.

There are some target_ memory reads where size_t makes sense.  Also bfd/
should use size_t and not int for the memory read sizes.



Thanks,
Jan



> gdb/ChangeLog
> 
> 2012-05-04 Siddhesh Poyarekar <siddhesh@redhat.com>

Formatting has double spaces:
2012-05-04  Siddhesh Poyarekar  <siddhesh@redhat.com>


> 
> 	* ada-lang.c (fat_pntr_bounds_bitpos): Return LONGEST.
> 	(fat_pntr_data_bitpos): Likewise.
> 	(desc_bound_bitpos): Likewise.
> 	(constrained_packed_array_type): Expand elt_bits parameter to
> 	LONGEST.
> 	(move_bits): Expand parameters src_offset and n to ULONGEST.
> 	(ada_index_struct_field): Expand parameters index and offset to
> 	LONGEST.
> 	(cond_offset_host): Expand parameter offset to LONGEST.
> 	(cond_offset_target): Likewise.
> 	(ada_type_of_array): Expand array_bitsize to LONGEST.
> 	(decode_constrained_packed_array_type): Expand bits to ULONGEST.
> 	(decode_constrained_packed_array): Expand bit_pos to LONGEST.
> 	(ada_value_primitive_packed_val): Expand parameter offset to
> 	LONGEST. Expand targ to LONGEST and ntarg to ULONGEST.

I think it should be 'LONGEST.  Expand' (double space).  Many times here.


> 	(ada_value_assign): Expand from_size to ULONGEST.
> 	(value_assign_to_component): Expand bits to ULONGEST.
> 	(ensure_lval): Expand len to ULONGEST.
> 	(value_pointer): Likewise.
> 	(value_tag_from_contents_and_address): Expand tag_byte_offset to
> 	LONGEST.
> 	(ada_value_primitive_field): Expand parameter offset to LONGEST.
> 	Expand bit_pos to LONGEST.
> 	(find_struct_field): Expand parameters offset and byte_offset_p
> 	to LONGEST. Expand bit_pos and fld_offset to LONGEST.
> 	(ada_search_struct_field): Expand parameter offset to LONGEST.
> 	Expand var_offset to LONGEST.
> 	(ada_index_struct_field): Expand parameters index and offset to
> 	LONGEST.
> 	(ada_index_struct_field_1): Expand parameters index_p and offset
> 	to LONGEST.
> 	(ada_value_struct_elt): Expand byte_offset to LONGEST.
> 	(align_value): Return ULONGEST. Expand parameter off to LONGEST
> 	and alignment to ULONGEST.
> 	(ada_template_to_fixed_record_type_1): Expand off, bit_len and
> 	fld_bit_len to ULONGEST. Expand field_offset to LONGEST. Use
> 	pulongest function to print TYPE_LENGTH.
> 	(to_fixed_array_type): Expand len to ULONGEST.
> 	* ada-lang.h (ada_val_print): Expand parameter embedded_offset
> 	to LONGEST.
> 	(ada_printstr): Expand parameter length to ULONGEST.
> 	(ada_value_primitive_packed_val): Expand parameter offset to
> 	LONGEST.
> 	* ada-typeprint.c (ada_print_type): Use pulongest to print
> 	TYPE_LENGTH.
> 	* ada-valprint.c (val_print_packed_array_elements): Expand
> 	eltlen to ULONGEST.
> 	(char_at): Expand parameter i to ULONGEST.
> 	(printstr): Expand parameter length to ULONGEST.
> 	(ada_printstr): Likewise.
> 	(ada_val_print): Expand embedded_offset to LONGEST.
> 	(ada_val_print_array): Expand eltlen, len and temp_len to
> 	ULONGEST.
> 	(ada_val_print_1): Expand parameter offset to ULONGEST. Expand
> 	len to ULONGEST.
> 	(print_variant_part): Expand parameters offset and outer_offset
> 	to LONGEST.
> 	(print_field_values): Likewise. Expand bit_pos to LONGEST.
> 	* alpha-tdep.c (struct alpha_arg): Expand member len to
> 	ULONGEST.
> 	(alpha_push_dummy_call): Expand len to ULONGEST.
> 	(alpha_extract_return_value): Expand length to ULONGEST.
> 	(alpha_store_return_value): Likewise.
> 	* amd64-tdep.c (amd64_classify_aggregate): Expand len,
> 	bitsize, endpos to ULONGEST and pos to LONGEST.
> 	(amd64_classify): Expand len to ULONGEST.
> 	(amd64_return_value): Expand len to LONGEST.
> 	(amd64_push_arguments): Expand num_elements, element to ULONGEST
> 	and len to LONGEST.
> 	(amd64_get_longjmp_target): Expand len to ULONGEST.
> 	* amd64-windows-tdep.c (amd64_windows_return_value): Expand
> 	len to LONGEST.
> 	* arm-tdep.c (arm_push_dummy_call): Expand len to LONGEST.
> 	(arm_extract_return_value): Expand len to ULONGEST.
> 	(arm_store_return_value): Likewise.
> 	* avr-tdep.c (avr_return_value): Expand i to ULONGEST.
> 	(push_stack_item): Expand parameter len to ULONGEST.
> 	(avr_push_dummy_call): Expand last_regnum, len to ULONGEST.
> 	* ax-gdb.c (gen_trace_static_fields): Expand length to
> 	ULONGEST.
> 	(gen_traced_pop): Likewise.
> 	(gen_left_shift): Expand parameter distance to LONGEST.
> 	(gen_offset): Expand parameter offset to LONGEST.
> 	(gen_bitfield_ref): Expand parameters start, end to LONGEST.
> 	Expand bound_start, bound_endi, offset to LONGEST.
> 	(gen_primitive_field): Expand parameter offset to LONGEST.
> 	(gen_struct_ref_recursive): Likewise.
> 	* bfin-tdep.c (bfin_push_dummy_call): Expand total_len, len,
> 	container_len to ULONGEST.
> 	(bfin_extract_return_value): Expand len to LONGEST.
> 	(bfin_store_return_value): Likewise.
> 	* breakpoint.c (update_watchpoint): Expand len to ULONGEST.
> 	(can_use_hardware_watchpoint): Likewise.
> 	(invalidate_bp_value_on_memory_change): Expand parameter len to
> 	LONGEST.
> 	* breakpoint.h (struct bp_location): Expand member length to
> 	ULONGEST.
> 	* c-lang.c (c_printstr): Expand parameter length to ULONGEST.

> 	Remove unused variable width.

This should be a separate patch, unrelated to this one.  Obvious for commit.


> 	(evaluate_subexp_c): Expand element_size, i to ULONGEST.
> 	* c-lang.h (c_val_print): Expand parameter embedded_offset to
> 	LONGEST.
> 	(c_printstr): Expand parameter length to ULONGEST.
> 	(cp_print_value_fields): Expand parameter offset to LONGEST.
> 	(cp_print_value_fields_rtti): Likewise.
> 	* c-typeprint.c (c_type_print_varspec_suffix): Remove cast
> 	down to int and use pulongest to print ULONGEST.
> 	* c-valprint.c (c_val_print): Expand parameter embedded_offset
> 	to LONGEST. Expand offset to LONGEST, eltlen to ULONGEST.
> 	(c_value_print): Expand top to LONGEST.
> 	* corefile.c (read_memory): Expand len to ULONGEST.
> 	(read_stack): Likewise.
> 	(write_memory): Likewise.
> 	* cp-abi.c (baseclass_offset): Return LONGEST. Expand
> 	parameter embedded_offset to LONGEST. Expand res to LONGEST.
> 	(value_virtual_fn_field): Expand parameter offset to LONGEST.
> 	(value_rtti_type): Expand parameter top to LONGEST *.
> 	* cp-abi.h (value_virtual_fn_field): Expand offset to LONGEST.
> 	(value_rtti_type): Expand top to LONGEST *.
> 	(baseclass_offset): Return LONGEST. Expand parameter
> 	embedded_offset to LONGEST.
> 	(struct cp_abi_ops): Expand parameter offset for
> 	virtual_fn_field to LONGEST. Expand parameter top to LONGEST
> 	* in value_rtti_type. Return LONGEST from baseclass_offset

Bogus '*' character.


> 	and expand parameter for embedded_offset to LONGEST.
> 	* cp-valprint.c (cp_print_value_fields): Expand parameter
> 	offset to LONGEST.
> 	(cp_print_value_fields_rtti): Likewise. Expand top to LONGEST.
> 	(cp_print_value): Expand parameter offset to LONGEST. Expand
> 	thisoffset, boffset to LONGEST.
> 	(cp_find_class_member): Expand bitsize to ULONGEST.
> 	* cris-tdep.c (push_stack_item): Expand parameter len to
> 	ULONGEST.
> 	(cris_push_dummy_call): Expand len, reg_demand, i to ULONGEST.
> 	(cris_store_return_value): Expand len to ULONGEST.
> 	(cris_extract_return_value): Likewise.
> 	* d-lang.h (d_val_print): Expand parameter embedded_offset to
> 	LONGEST.
> 	* d-valprint.c (dynamic_array_type): Likewise.
> 	(d_val_print): Likewise.

> 	* doc/observer.texi (memory_changed): Expand parameter len to
> 	LONGEST.

doc/ has its own separate ChangeLog file.


> 	* doublest.c (floatformat_from_length): Likewise. Use
> 	pulongest to format string for ULONGEST.
> 	* dwarf2loc.c (copy_bitwise): Expand parameters
> 	dest_offset_bits, bit_count to ULONGEST. Rename parameter
> 	source_offset_bits to source_offset and expand to ULONGEST. New
> 	variable source_offset_bits.
> 	(read_pieced_value): Expand offset, dest_offset_bits,
> 	source_offset_bits, source_offset to LONGEST. Expand type_len,
> 	this_size, this_size_bits to ULONGEST.
> 	(write_pieced_value): Expand type_len, this_size, this_size_bits
> 	to ULONGEST. Expand dest_offset_bits, source_offset_bits,
> 	dest_offset, source_offset to LONGEST.
> 	(check_pieced_value_bits): Expand parameter bit_length to
> 	ULONGEST.
> 	(check_pieced_value_validity): Likewise.
> 	(check_pieced_synthetic_pointer): Likewise.
> 	(indirect_pieced_value): Expand bit_length to ULONGEST. Expand
> 	bit_offset to LONGEST.
> 	(dwarf2_evaluate_loc_desc_full): Expand n to ULONGEST.

> 	* dwarf2read.c (struct dwarf_block): ULONGEST size.

This description is not a sentence.


> 	(dwarf2_const_value_length_mismatch_complaint): Expand
> 	parameters arg2 and arg3 to ULONGEST. Use pulongest to print
> 	arg2 and arg3. (dwarf2_add_field): Expand anonymous size to

Opening parenthesis should be at the beginning of a line.

> 	ULONGEST. (dump_die_shallow): Use pulongest to print

And here again and I see more occurences below.


> 	dwarf_block.size.
> 	* eval.c (evaluate_struct_tuple): Expand bitpos to LONGEST.
> 	(init_array_element): Expand element_size to ULONGEST.
> 	(binop_promote): Expand promoted_len1, promoted_len2, result_len
> 	to ULONGEST.
> 	(evaluate_subexp_standard): Expand mem_offset, top to LONGEST.
> 	Expand element_size to ULONGEST.
> 	* f-lang.c (f_printstr): Expand parameter length to ULONGEST.
> 	* f-lang.h (f_val_print): Expand parameter embedded_offset to
> 	LONGEST.
> 	* f-valprint.c (f77_array_offset_tbl): Make LONGEST.
> 	(f77_create_arrayprint_offset_tbl): Expand eltlen to ULONGEST.
> 	(f77_print_array_1): Expand parameter embedded_offset to
> 	LONGEST. (f77_print_array): Likewise.
> 	(f_val_print): Likewise. Expand offset to LONGEST.
> 	* findcmd.c (parse_find_args): Expand val_bytes to ULONGEST.
> 	* findvar.c (extract_unsigned_integer): Remove unnecessary
> 	cast.
> 	(default_read_var_value): Expand len to ULONGEST.
> 	(default_value_from_register): Likewise.
> 	(read_frame_register_value): Expand offset, reg_offset to
> 	LONGEST. Expand len, reg_len to ULONGEST.
> 	* frv-tdep.c (frv_extract_return_value): Expand len to
> 	ULONGEST. Use pulongest to format print len.
> 	(frv_push_dummy_call): Expand len to ULONGEST.
> 	(frv_store_return_value): Likewise. Use pulongest to format
> 	print len.
> 	* gdbcore.h (read_memory): Expand parameter len to ULONGEST.
> 	(read_stack): Likewise.
> 	(write_memory): Likewise.
> 	* gdbtypes.c (init_type): Expand parameter length to ULONGEST.
> 	(is_unique_ancestor_worker): Expand parameters offset,
> 	embedded_offset to LONGEST. Expand this_offset to LONGEST.
> 	(recursive_dump_type): Use pulongest to format print
> 	TYPE_LENGTH. Use plongest to format print TYPE_FIELD_BITPOS.
> 	(arch_type): Expand parameter length to ULONGEST.
> 	* gdbtypes.h (type.main_type.fld_bnds.fields): Expand bitpos
> 	to LONGEST.
> 	(type): Expand length to ULONGEST.
> 	(init_type): Expand parameter length to ULONGEST.
> 	(arch_type): Likewise.
> 	* gnu-v2-abi.c (gnuv2_virtual_fn_field): Expand parameter
> 	offset to LONGEST.
> 	(gnuv2_value_rtti_type): Expand parameter top to LONGEST *.
> 	(gnuv2_baseclass_offset): Return LONGEST. Expand parameter
> 	embedded_offset to LONGEST. Expand field_offset, boffset to
> 	LONGEST, field_length to ULONGEST.
> 	* gnu-v3-abi.c (build_gdb_vtable_type): Expand offset to
> 	LONGEST.
> 	(vtable_address_point_offset): Return LONGEST.
> 	(gnuv3_rtti_type): Expand parameter top_p to LONGEST *.
> 	(gnuv3_virtual_fn_field): Expand parameter offset to LONGEST.
> 	(gnuv3_baseclass_offset): Return LONGEST. Expand parameter
> 	embedded_ofset to LONGEST. Expand cur_base_offset, base_offset
> 	to LONGEST.
> 	(gnuv3_find_method_in): Expand pos to LONGEST.
> 	* go-lang.h (go_val_print): Expand parameter embedded_offset
> 	to LONGEST.
> 	* go-valprint.c (go_val_print): Likewise.
> 	* h8300-tdep.c (h8300_push_dummy_call): Expand stack_alloc,
> 	stack_offset, len, padded_len, offset to LONGEST.
> 	* hppa-tdep.c (hppa64_push_dummy_call): Expand len to
> 	ULONGEST.
> 	(hppa64_return_value): Likewise.
> 	* i386-darwin-tdep.c (i386_darwin_arg_type_alignment): Return
> 	ULONGEST. Expand res to ULONGEST.
> 	(i386_darwin_push_dummy_call): Expand arg_spaces, len, align to
> 	ULONGEST.
> 	* i386-nat.c (i386_handle_nonaligned_watchpoint): Expand
> 	parameter len to ULONGEST.
> 	(i386_region_ok_for_watchpoint): Expand parameter len to
> 	LONGEST.
> 	* i386-tdep.c (i386_push_dummy_call): Expand arg_space,
> 	arg_space_used, len to ULONGEST.
> 	(i386_extract_return_value): Expand len to ULONGEST. Use
> 	pulongest to format print len.
> 	(i386_store_return_value): Likewise.
> 	* ia64-tdep.c (ia64_extract_return_value): Expand n to
> 	ULONGEST.
> 	(ia64_store_return_value): Likewise.
> 	(ia64_push_dummy_call): Expand argoffset, len, nslots, memslots
> 	to ULONGEST.
> 	* infcall.c (call_function_by_hand): Expand len to ULONGEST.
> 	* infrun.c (save_infcall_suspend_state): Expand len to
> 	ULONGEST.
> 	(restore_infcall_suspend_state): Eliminate single-use variable
> 	len.
> 	* iq2000-tdep.c (iq2000_store_return_value): Expand len to
> 	ULONGEST.
> 	(iq2000_extract_return_value): Likewise. Use len instead of
> 	TYPE_LENGTH.
> 	(iq2000_push_dummy_call): Expand typelen, stackspace to
> 	ULONGEST.
> 	* jv-lang.c (java_link_class_type): Expand boffset to LONGEST.
> 	(java_printstr): Expand parameter length to ULONGEST.
> 	* jv-lang.h (java_val_print): Expand parameter embedded_offset
> 	to LONGEST.
> 	* jv-valprint.c (java_print_value_fields): Expand parameter
> 	offset to LONGEST.
> 	(java_val_print): Expand parameter embedded_offset to LONGEST.
> 	* language.c (unk_lang_printstr): Expand parameter length to
> 	ULONGEST.
> 	(unk_lang_val_print): Expand parameter embedded_offset to
> 	LONGEST.
> 	* language.h (language_defn): Expand parameter length of
> 	la_printstr to ULONGEST. Expand parameter embedded_offset of
> 	la_val_print to LONGEST.
> 	* lm32-tdep.c (lm32_push_dummy_call): Expand len to ULONGEST.
> 	(lm32_store_return_value): Likewise.
> 	* m2-lang.c (m2_printstr): Expand parameter length to
> 	ULONGEST.
> 	* m2-lang.h (m2_val_print): Expand parameter embedded_offset
> 	to ULONGEST.
> 	* m2-typeprint.c (m2_array): Use pulongest to print
> 	TYPE_LENGTH.
> 	(m2_enum): expand lastval to LONGEST.
> 	* m2-valprint.c (m2_print_long_set): Expand parameter
> 	embedded_offset to LONGEST.
> 	(m2_print_unbounded_array): Likewise.
> 	(m2_print_array_contents): Likewise. Eliminate eltlen and use
> 	TYPE_LENGTH directly.
> 	(m2_val_print): Expand parameter embedded_offset to LONGEST.
> 	Expand i, len, temp_len to ULONGEST. Remove eltlen, use
> 	TYPE_LENGTH directly.
> 	* m32r-tdep.c (m32r_push_dummy_call): Expand len to ULONGEST.
> 	(m32r_extract_return_value): Likewise.
> 	* m68hc11-tdep.c (m68hc11_push_dummy_call): Expand len to
> 	ULONGEST.
> 	(m68hc11_store_return_value): Likewise.
> 	* m68k-tdep.c (m68k_extract_return_value): Expand len to
> 	ULONGEST. Use pulongest to format print len.
> 	(m68k_svr4_extract_return_value): Replace single-use variable
> 	len with TYPE_LENGTH.
> 	(m68k_store_return_value): Expand len to ULONGEST. Use pulongest
> 	to format print len.
> 	(m68k_svr4_store_return_value): Replace single-use variable len
> 	with TYPE_LENGTH.
> 	(m68k_push_dummy_call): Expand len, container_len, offset to
> 	ULONGEST.
> 	* m88k-tdep.c (m88k_store_arguments): Expand
> 	num_register_words, num_stack_words, len to ULONGEST.
> 	(m88k_return_value): Expand len to ULONGEST.
> 	* memrange.c (mem_ranges_overlap): Expand parameters len1,
> 	len2 to ULONGEST.
> 	* memrange.h (struct mem_range): Expand member length to
> 	ULONGEST.
> 	(mem_ranges_overlap): Expand parameters len1, len2 to ULONGEST.
> 	* mep-tdep.c (push_large_arguments): Expand arg_len to
> 	ULONGEST.
> 	(mep_push_dummy_call): Expand arg_size to ULONGEST.
> 	* microblaze-tdep.c (microblaze_store_return_value): Expand
> 	len to ULONGEST.
> 	* 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 ULONGEST. Use
> 	pulongest to format print len.
> 	(mips_n32n64_fp_arg_chunk_p): Expand parameter offset to
> 	LONGEST. Expand pos to LONGEST.
> 	(mips_n32n64_return_value): Expand offset to LONGEST. Use
> 	plongest to format print offset.
> 	(mips_o32_push_dummy_call): Expand len to ULONGEST. Eliminate
> 	single-use variable arglen. Use pulongest to format print len.
> 	(mips_o64_push_dummy_call): Expand len, stack_offset to
> 	ULONGEST. Eliminate single-use variable arglen. use pulongest

Capitalize 'use'.


> 	to format print len.
> 	* mn10300-tdep.c (mn10300_type_align): Return ULONGEST.
> 	Expand align, falign to ULONGEST.
> 	(mn10300_push_dummy_call): Expand len, arg_len to ULONGEST.
> 	* moxie-tdep.c (moxie_store_return_value): Expand len to
> 	ULONGEST.
> 	(moxie_extract_return_value): Likewise.
> 	* mt-tdep.c (mt_push_dummy_call): Expand stack_dest, typelen
> 	to ULONGEST.
> 	* objc-lang.c (objc_printstr): Expand parameter length to
> 	ULONGEST.
> 	* opencl-lang.c (lookup_opencl_vector_type): Expand parameter
> 	el_length to ULONGEST. Expand length to ULONGEST.
> 	(lval_func_read): Expand offset, n, i, j to LONGEST. Expand
> 	elsize to ULONGEST.
> 	(lval_func_write): Likewise.
> 	(lval_func_check_validity): Expand parameter length to ULONGEST.
> 	Expand elsize to ULONGEST. Expand start, end, i to LONGEST.
> 	(lval_func_check_any_valid): Expand elsize to ULONGEST.
> 	(lval_func_check_synthetic_pointer): Expand parameter offset to
> 	LONGEST. Expand parameter length to ULONGEST. Expand elsize to
> 	ULONGEST. Expand start, end, i to LONGEST.
> 	* p-lang.c (is_pascal_string_type): Expand parameter
> 	length_pos, string_pos to LONGEST *. Expand parameter
> 	length_size to ULONGEST *.
> 	(pascal_printstr): Expand parameter length to ULONGEST.
> 	* p-lang.h (pascal_val_print): Expand parameter
> 	embedded_offset to LONGEST.
> 	(is_pascal_string_type): Expand parameter length_pos, string_pos
> 	to LONGEST *. Expand parameter length_size to ULONGEST *.
> 	(pascal_printstr): Expand parameter length to ULONGEST.
> 	(pascal_object_print_value_fields): Expand parameter offset to
> 	LONGEST.
> 	* p-typeprint.c (pascal_type_print_base): Expand lastval to
> 	LONGEST.
> 	* p-valprint.c (pascal_val_print): Expand parameter
> 	embedded_offset to LONGEST. Expand eltlen, length_size to
> 	ULONGEST. Expand length_pos, string_pos to LONGEST.
> 	(pascal_object_print_value_fields): Expand parameter offset to
> 	LONGEST.
> 	(pascal_object_print_value): Likewise. Expand boffset,
> 	thisoffset to LONGEST.
> 	* ppc-linux-nat.c (check_condition): Expand parameter len to
> 	ULONGEST *.
> 	* ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call): Expand
> 	argoffset, structoffset, len, i, nelt to ULONGEST.
> 	(do_ppc_sysv_return_value): Expand i, nelt, offset to ULONGEST.
> 	(ppc64_sysv_abi_push_dummy_call): Expand len to ULONGEST.
> 	(ppc64_sysv_abi_return_value): Expand n_regs, i, offset to
> 	ULONGEST.
> 	* printcmd.c (print_formatted): Expand len to ULONGEST.
> 	(float_type_from_length): Likewise.
> 	(print_scalar_formatted): Likewise.
> 	* python/py-prettyprint.c (apply_val_pretty_printer): Expand
> 	parameter embedded_offset to LONGEST.
> 	* python/python.h (apply_val_pretty_printer): Likewise.
> 	* regcache.c (regcache_xfer_part): Expand parameter offset to
> 	LONGEST.
> 	(regcache_cooked_read_part): Likewise.
> 	(regcache_cooked_write_part): Likewise.
> 	* regcache.h (regcache_cooked_read_part): Likewise.
> 	(regcache_cooked_write_part): Likewise.
> 	* remote.c (remote_write_bytes_aux): Expand parameter len to
> 	LONGEST.
> 	(remote_write_bytes): Likewise.
> 	(remote_region_ok_for_hw_watchpoint): Likewise.
> 	* rl78-tdep.c (rl78_push_dummy_call): Expand len,
> 	container_len to ULONGEST.
> 	* rs6000-aix-tdep.c (rs6000_push_dummy_call): Expand len to
> 	ULONGEST.
> 	(ran_out_of_registers_for_arguments): Expand space, jj to
> 	ULONGEST.
> 	* s390-tdep.c (s390_value_from_register): Eliminate single use
> 	variable len.
> 	(s390_function_arg_pass_by_reference): Likewise.
> 	(s390_function_arg_float): Eliminate single-use variable length.
> 	(s390_push_dummy_call): Likewise. Expand length to ULONGEST.
> 	(s390_frame_align): Eliminate single-us variable length.
> 	(s390_return_value): Expand length to ULONGEST.
> 	* score-tdep.c (score_push_dummy_call): Expand arglen to
> 	ULONGEST.
> 	* sh-tdep.c (sh_extract_return_value_nofpu): Epand len to

Typo, 'Expand'.


> 	ULONGEST.
> 	(sh_store_return_value_nofpu): Likewise.
> 	* sh64-tdep.c (sh64_push_dummy_call): Expand stack_offset,
> 	stack_alloc, len to ULONGEST.
> 	(sh64_extract_return_value): Expand len to ULONGEST.
> 	(sh64_store_return_value): Likewise.
> 	* sparc-tdep.c (sparc32_store_arguments): Likewise.
> 	* 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 ULONGEST.
> 	* spu-tdep.c (spu_value_from_register): Likewise.
> 	* stack.c (read_frame_arg): Expand len, len_deref to ULONGEST.
> 	(print_frame_args): Expand current_offset, arg_size to ULONGEST.
> 	* symfile-mem.c (symfile_target_read_memory): New
> 	function. Wrap around target_read_memory.
> 	(symbol_file_add_from_memory): Use symfile_target_read_memory.
> 	* symmisc.c (print_symbol): Expand i to ULONGEST. Use
> 	pulongest to format print TYPE_LENGTH.
> 	* target.c (target_read_memory): Expand parameter len to
> 	LONGEST.
> 	(target_read_stack): Likewise.
> 	(target_write_memory): Likewise.
> 	(target_write_raw_memory): Likewise.
> 	(default_region_ok_for_hw_watchpoint): Likewise.
> 	(debug_to_region_ok_for_hw_watchpoint): Likewise.
> 	* target.h (struct target_ops): Expand parameter len to
> 	LONGEST for to_region_ok_for_hw_watchpoint.
> 	(target_read_memory): Expand parameter len to LONGEST.
> 	(target_read_stack): Likewise.
> 	(target_write_memory): Likewise.
> 	(target_write_raw_memory): Likewise.
> 	* tracepoint.c (collect_symbol): Expand len to ULONGEST.
> 	(encode_actions_1): Make addr as CORE_ADDR. Expand len to
> 	ULONGEST.
> 	(scope_info): Expand j to ULONGEST. Use pulongest to format
> 	  print TYPE_LENGTH.

Excessive indentation.  Many times below.


> 	* typeprint.c (whatis_exp): Expand top to LONGEST.
> 	* v850-tdep.c (v850_push_dummy_call): Expand len to ULONGEST.
> 	(v850_extract_return_value): Expand len to LONGEST.
> 	(v850_store_return_value): Expand len to ULONGEST.
> 	* valarith.c (value_subscripted_rvalue): Expand elt_size,
> 	elt_offs to ULONGEST.
> 	(value_binop): Expand len to LONGEST.
> 	(value_logical_not): Expand len1, len2 to LONGEST.
> 	* valops.c (value_allocate_space_in_inferior): Expand
> 	parameter len to ULONGEST. Use value_from_ulongest to get the
> 	value for len.
> 	(value_cast_structs): Expand top to LONGEST.
> 	(value_cast): Expand val_length, element_length to ULONGEST.
> 	(dynamic_cast_check_1): Expand parameter embedded_offset to
> 	LONGEST. Expand offset to LONGEST.
> 	(dynamic_cast_check_2): Likewise.
> 	(value_dynamic_cast): Expand top to LONGEST.
> 	(value_fetch_lazy): Expand length to ULONGEST.
> 	(read_value_memory): Expand parameter length to ULONGEST.
> 	(value_assign): Expand changed_len to ULONGEST. Expand offset to
> 	LONGEST.
> 	(value_array): Expand typelength to ULONGEST.
> 	(search_struct_field): Expand parameter offset to LONGEST.
> 	  Expand new_offset, boffset to LONGEST.
> 	(search_struct_method): Expand parameter offset to LONGEST.
> 	Expand base_offset, this_offset to LONGEST.
> 	(find_method_list): Expand parameter offset to LONGEST,
> 	  parameter boffset to LONGEST *. Expand base_offset to LONGEST.
> 	(value_find_oload_method_list): Expand parameter boffset to
> 	LONGEST *.
> 	(find_overload_match): Expand boffset to LONGEST.
> 	(value_struct_elt_for_reference): Expand parameter offset to
> 	LONGEST. Expand base_offset to LONGEST.
> 	(value_rtti_indirect_type): Expand parameter top to LONGEST *.
> 	(value_full_object): Expand parameter xtop to LONGEST. Expand
> 	  top to LONGEST.
> 	* valprint.c (valprint_check_validity): Expand parameter
> 	embedded_offset to LONGEST.
> 	(generic_val_print): Likewise.
> 	(val_print): Likewise.
> 	(val_print_scalar_formatted): Likewise.
> 	(print_hex_chars): Expand parameter len to ULONGEST.
> 	(val_print_array_elements): Expand parameter embedded_offset to
> 	LONGEST. Expand len, eltlen to ULONGEST.
> 	(generic_printstr): Expand parameter length to ULONGEST.
> 	* valprint.h (val_print_array_elements): Expand parameter
> 	embedded_offset to LONGEST.
> 	(val_print_scalar_formatted): Likewise.
> 	(print_hex_chars): Expand parameter len to ULONGEST.
> 	(generic_val_print): Expand parameter embedded_offset to
> 	  LONGEST. (generic_printstr): Expand parameter length to

Again, indentation and '(' not at the first column.

> 	  ULONGEST.
> 	* value.c (struct range): Expand member offset to LONGEST.
> 	Expand member length to ULONGEST.
> 	(ranges_overlap): Expand parameters offset1, offset2 to LONGEST.
> 	Expand parameters len1, len2 to ULONGEST.
> 	(range_contain): Expand parameter offset to LONGEST. Expand
> 	parameter length to ULONGEST.
> 	(struct value): Expand members offset, embedded_offset,
> 	pointed_to_offset to LONGEST.
> 	(value_bytes_available): Expand parameter offset to LONGEST,
> 	parameter length to ULONGEST.
> 	(mark_value_bytes_unavailable): Likewise.
> 	(find_first_range_overlap): Likewise.
> 	(value_available_contents_eq): Expand parameters offset1,
> 	  offset2 to LONGEST. Expand parameter length to ULONGEST.
> 	(value_offset): Return LONGEST.
> 	(set_value_offset): Expand parameter offset to LONGEST.
> 	(value_contents_copy_raw): Expand parameters src_offset,
> 	dst_offset to LONGEST. Expand parameters length to ULONGEST.
> 	(value_contents_copy): Likewise.
> 	(value_contents_equal): Expand len to ULONGEST.
> 	(value_bits_valid): Expand parameter offset to LONGEST, length
> 	  to ULONGEST.
> 	(value_bits_synthetic_pointer): Likewise.
> 	(value_embedded_offset): Return LONGEST.
> 	(set_value_embedded_offset): Expand parameter val to LONGEST.
> 	(value_pointed_to_offset): Return LONGEST.
> 	(set_value_pointed_to_offset): Expand parameter val to LONGEST.
> 	(set_internalvar_component): Expand parameter offset to LONGEST.
> 	(value_primitive_field): Likewise. Expand bitpos, boffset to
> 	LONGEST, container_bitpos to ULONGEST.
> 	(value_fn_field): Expand parameter offset to LONGEST.
> 	(unpack_value_bits_as_long_1): Expand parameters
> 	  embedded_offset, bitpos to LONGEST. Expand read_offset to
> 	  LONGEST. (unpack_value_bits_as_long): Expand parameter
> 	  embeded_offset to LONGEST.
> 	(unpack_value_field_as_long_1): Likewise. Expand bitpos to
> 	LONGEST.
> 	(unpack_value_field_as_long): Expand parameter embedded_offset
> 	  to LONGEST.
> 	(value_field_bitfield): Likewise.
> 	(modify_field): Expand parameter bitpos to LONGEST. Expand
> 	bytesize to ULONGEST.
> 	* value.h (value_offset): Return LONGEST.
> 	(set_value_offset): Expand parameter offset to LONGEST.
> 	(value_pointed_to_offset): Return LONGEST.
> 	(set_value_pointed_to_offset): Expand parameter val to LONGEST.
> 	(value_embedded_offset): Return LONGEST.
> 	(set_value_embedded_offset): Expand parameter val to LONGEST.
> 	(struct lval_funcs): Expand parameter offset to LONGEST, length
> 	  to ULONGEST for check_validity. Likewise for
> 	check_synthetic_pointer.
> 	(valprint_check_validity): Expand parameter embedded_offset to
> 	LONGEST.
> 	(value_bits_valid): Expand parameter offset to LONGEST, length
> 	  to ULONGEST.
> 	(value_bits_synthetic_pointer): Likewise.
> 	(mark_value_bytes_unavailable): Expand parameter offset to
> 	LONGEST, parameter length to ULONGEST.
> 	(value_available_contents_eq): Expand parameters offset1,
> 	  offset2 to LONGEST. Expand parameter length to ULONGEST.
> 	(read_value_memory): Expand parameter length to ULONGEST.
> 	(unpack_value_bits_as_long): Expand parameter embeded_offset to
> 	LONGEST.
> 	(unpack_value_field_as_long): Likewise.
> 	(value_field_bitfield): Likewise.
> 	(value_contents_copy_raw): Expand parameters src_offset,
> 	dst_offset to LONGEST. Expand parameters length to ULONGEST.
> 	(value_contents_copy): Likewise.
> 	(value_find_oload_method_list): Expand parameter boffset to
> 	LONGEST *.
> 	(value_primitive_field): Expand parameter offset to LONGEST.
> 	(value_rtti_indirect_type): Expand parameter top to LONGEST *.
> 	(value_full_object): Expand parameter xtop to LONGEST.
> 	(set_internalvar_component): Expand parameter offset to LONGEST.
> 	(value_fn_field): Expand parameter offset to LONGEST.
> 	(modify_field): Expand parameter bitpos to LONGEST.
> 	(val_print): Expand parameter embedded_offset to LONGEST.
> 	(value_allocate_space_in_inferior): Expand parameter len to
> 	ULONGEST.
> 	* vax-tdep.c (vax_store_arguments): Expand count, len to
> 	ULONGEST.
> 	(vax_return_value): Expand len to ULONGEST.
> 	* xstormy16-tdep.c (xstormy16_extract_return_value): Expand
> 	len, i to ULONGEST.
> 	(xstormy16_store_return_value): Likewise.
> 	(xstormy16_push_dummy_call): Expand j to LONGEST, typelen to
> 	ULONGEST.
> 	(xstormy16_push_dummy_call):
> 	* xtensa-tdep.c (xtensa_extract_return_value): Expand len to
> 	ULONGEST. Use pulongest to format print len.
> 	(xtensa_store_return_value): Likewise.
> 	(xtensa_push_dummy_call): Expand size, onstack_size, length to
> 	ULONGEST. Expand offset to LONGEST. Use pulongest to format
> 	print TYPE_LENGTH.
> 
> testsuite/ChangeLog:
> 
> 2012-05-04 Siddhesh Poyarekar <siddhesh@redhat.com>

Formatting has double spaces:
2012-05-04  Siddhesh Poyarekar  <siddhesh@redhat.com>


> 
> 	* gdb.base/structs-longest-bitpos.c: New test case.
> 	* gdb.base/structs-longest-bitpos.exp: New test case.

> diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
> index 180fadb..4417cf1 100644
> --- a/gdb/ada-lang.c
> +++ b/gdb/ada-lang.c
> @@ -80,7 +80,7 @@ static struct type *desc_bounds_type (struct type *);
>  
>  static struct value *desc_bounds (struct value *);
>  
> -static int fat_pntr_bounds_bitpos (struct type *);
> +static LONGEST fat_pntr_bounds_bitpos (struct type *);
>  
>  static int fat_pntr_bounds_bitsize (struct type *);
>  
> @@ -88,13 +88,13 @@ static struct type *desc_data_target_type (struct type *);
>  
>  static struct value *desc_data (struct value *);
>  
> -static int fat_pntr_data_bitpos (struct type *);
> +static LONGEST fat_pntr_data_bitpos (struct type *);
>  
>  static int fat_pntr_data_bitsize (struct type *);
>  
>  static struct value *desc_one_bound (struct value *, int, int);
>  
> -static int desc_bound_bitpos (struct type *, int, int);
> +static LONGEST desc_bound_bitpos (struct type *, int, int);
>  
>  static int desc_bound_bitsize (struct type *, int, int);
>  
> @@ -174,7 +174,7 @@ static struct type *static_unwrap_type (struct type *type);
>  
>  static struct value *unwrap_value (struct value *);
>  
> -static struct type *constrained_packed_array_type (struct type *, long *);
> +static struct type *constrained_packed_array_type (struct type *, ULONGEST *);
X
>  
>  static struct type *decode_constrained_packed_array_type (struct type *);
>  
> @@ -189,7 +189,8 @@ static int ada_is_unconstrained_packed_array_type (struct type *);
>  static struct value *value_subscript_packed (struct value *, int,
>                                               struct value **);
>  
> -static void move_bits (gdb_byte *, int, const gdb_byte *, int, int, int);
> +static void move_bits (gdb_byte *, int, const gdb_byte *, ULONGEST, ULONGEST,
X
> +		       int);
>  
>  static struct value *coerce_unspec_val_to_type (struct value *,
>                                                  struct type *);
> @@ -217,14 +218,14 @@ static struct value *value_val_atr (struct type *, struct value *);
>  static struct symbol *standard_lookup (const char *, const struct block *,
>                                         domain_enum);
>  
> -static struct value *ada_search_struct_field (char *, struct value *, int,
> +static struct value *ada_search_struct_field (char *, struct value *, LONGEST,
>                                                struct type *);
>  
> -static struct value *ada_value_primitive_field (struct value *, int, int,
> +static struct value *ada_value_primitive_field (struct value *, LONGEST, int,
>                                                  struct type *);
>  
> -static int find_struct_field (const char *, struct type *, int,
> -                              struct type **, int *, int *, int *, int *);
> +static int find_struct_field (const char *, struct type *, LONGEST,
> +			      struct type **, LONGEST *, int *, int *, int *);
>  
>  static struct value *ada_to_fixed_value_create (struct type *, CORE_ADDR,
>                                                  struct value *);
> @@ -240,7 +241,7 @@ static void ada_language_arch_info (struct gdbarch *,
>  
>  static void check_size (const struct type *);
>  
> -static struct value *ada_index_struct_field (int, struct value *, int,
> +static struct value *ada_index_struct_field (LONGEST, struct value *, LONGEST,
>  					     struct type *);
>  
>  static struct value *assign_aggregate (struct value *, struct value *, 
> @@ -586,7 +587,7 @@ coerce_unspec_val_to_type (struct value *val, struct type *type)
>  }
>  
>  static const gdb_byte *
> -cond_offset_host (const gdb_byte *valaddr, long offset)
> +cond_offset_host (const gdb_byte *valaddr, LONGEST offset)
>  {
>    if (valaddr == NULL)
>      return NULL;
> @@ -595,7 +596,7 @@ cond_offset_host (const gdb_byte *valaddr, long offset)
>  }
>  
>  static CORE_ADDR
> -cond_offset_target (CORE_ADDR address, long offset)
> +cond_offset_target (CORE_ADDR address, LONGEST offset)
>  {
>    if (address == 0)
>      return 0;
> @@ -1601,7 +1602,7 @@ desc_bounds (struct value *arr)
>  /* If TYPE is the type of an array-descriptor (fat pointer),  the bit
>     position of the field containing the address of the bounds data.  */
>  
> -static int
> +static LONGEST
>  fat_pntr_bounds_bitpos (struct type *type)
>  {
>    return TYPE_FIELD_BITPOS (desc_base_type (type), 1);
> @@ -1667,7 +1668,7 @@ desc_data (struct value *arr)
>  /* If TYPE is the type of an array-descriptor (fat pointer), the bit
>     position of the field containing the address of the data.  */
>  
> -static int
> +static LONGEST
>  fat_pntr_data_bitpos (struct type *type)
>  {
>    return TYPE_FIELD_BITPOS (desc_base_type (type), 0);
> @@ -1702,7 +1703,7 @@ desc_one_bound (struct value *bounds, int i, int which)
>     of the Ith lower bound stored in it, if WHICH is 0, and the Ith upper
>     bound, if WHICH is 1.  The first bound is I=1.  */
>  
> -static int
> +static LONGEST
>  desc_bound_bitpos (struct type *type, int i, int which)
>  {
>    return TYPE_FIELD_BITPOS (desc_base_type (type), 2 * i + which - 2);
> @@ -1892,7 +1893,7 @@ ada_type_of_array (struct value *arr, int bounds)
>  	         zero, and does not need to be recomputed.  */
>  	      if (lo < hi)
>  		{
> -		  int array_bitsize =
> +		  ULONGEST array_bitsize =
X
>  		        (hi - lo + 1) * TYPE_FIELD_BITSIZE (elt_type, 0);
>  
>  		  TYPE_LENGTH (array_type) = (array_bitsize + 7) / 8;
> @@ -2044,7 +2045,7 @@ decode_packed_array_bitsize (struct type *type)
>     in bits.  */
>  
>  static struct type *
> -constrained_packed_array_type (struct type *type, long *elt_bits)
> +constrained_packed_array_type (struct type *type, ULONGEST *elt_bits)
X
>  {
>    struct type *new_elt_type;
>    struct type *new_type;
> @@ -2096,7 +2097,7 @@ decode_constrained_packed_array_type (struct type *type)
>    char *name;
>    const char *tail;
>    struct type *shadow_type;
> -  long bits;
> +  ULONGEST bits;
X
>  
>    if (!raw_name)
>      raw_name = ada_type_name (desc_base_type (type));
> @@ -2167,7 +2168,8 @@ decode_constrained_packed_array (struct value *arr)
>   	 array with no wrapper.  In order to interpret the value through
>   	 the (left-justified) packed array type we just built, we must
>   	 first left-justify it.  */
> -      int bit_size, bit_pos;
> +      int bit_size;
> +      LONGEST bit_pos;
>        ULONGEST mod;
>  
>        mod = ada_modulus (value_type (arr)) - 1;
> @@ -2268,15 +2270,16 @@ has_negatives (struct type *type)
>  
>  struct value *
>  ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
> -				long offset, int bit_offset, int bit_size,
> +				LONGEST offset, int bit_offset, int bit_size,
>                                  struct type *type)
>  {
>    struct value *v;
> -  int src,                      /* Index into the source area */
> -    targ,                       /* Index into the target area */
> -    srcBitsLeft,                /* Number of source bits left to move */
> -    nsrc, ntarg,                /* Number of source and target bytes */
> -    unusedLS,                   /* Number of bits in next significant
> +  int src;                      /* Index into the source area */
> +  LONGEST targ;                 /* Index into the target area */
> +  int srcBitsLeft,              /* Number of source bits left to move */
> +    nsrc;                       /* Number of source bytes */
> +  ULONGEST ntarg;               /* Number of target bytes */
X
> +  int unusedLS,                 /* Number of bits in next significant
>                                     byte of source that are unused */
>      accumSize;                  /* Number of meaningful bits in accum */
>    unsigned char *bytes;         /* First byte containing data to unpack */
> @@ -2426,7 +2429,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
>     not overlap.  */
>  static void
>  move_bits (gdb_byte *target, int targ_offset, const gdb_byte *source,
> -	   int src_offset, int n, int bits_big_endian_p)
> +	   ULONGEST src_offset, ULONGEST n, int bits_big_endian_p)
X
>  {
>    unsigned int accum, mask;
>    int accum_bits, chunk_size;
> @@ -2516,7 +2519,7 @@ ada_value_assign (struct value *toval, struct value *fromval)
>      {
>        int len = (value_bitpos (toval)
>  		 + bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
> -      int from_size;
> +      ULONGEST from_size;
X
>        char *buffer = (char *) alloca (len);
>        struct value *val;
>        CORE_ADDR to_addr = value_address (toval);
> @@ -2562,7 +2565,7 @@ value_assign_to_component (struct value *container, struct value *component,
>      (LONGEST)  (value_address (component) - value_address (container));
>    int bit_offset_in_container = 
>      value_bitpos (component) - value_bitpos (container);
> -  int bits;
> +  ULONGEST bits;
X
>    
>    val = value_cast (value_type (component), val);
>  
> @@ -4082,7 +4085,7 @@ ensure_lval (struct value *val)
>    if (VALUE_LVAL (val) == not_lval
>        || VALUE_LVAL (val) == lval_internalvar)
>      {
> -      int len = TYPE_LENGTH (ada_check_typedef (value_type (val)));
> +      ULONGEST len = TYPE_LENGTH (ada_check_typedef (value_type (val)));
X
>        const CORE_ADDR addr =
>          value_as_long (value_allocate_space_in_inferior (len));
>  
> @@ -4156,7 +4159,7 @@ static CORE_ADDR
>  value_pointer (struct value *value, struct type *type)
>  {
>    struct gdbarch *gdbarch = get_type_arch (type);
> -  unsigned len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
>    gdb_byte *buf = alloca (len);
>    CORE_ADDR addr;
>  
> @@ -6044,7 +6047,7 @@ value_tag_from_contents_and_address (struct type *type,
>  				     const gdb_byte *valaddr,
>                                       CORE_ADDR address)
>  {
> -  int tag_byte_offset;
> +  LONGEST tag_byte_offset;
>    struct type *tag_type;
>  
>    if (find_struct_field ("_tag", type, 0, &tag_type, &tag_byte_offset,
> @@ -6427,7 +6430,7 @@ ada_in_variant (LONGEST val, struct type *type, int field_num)
>     only in that it can handle packed values of arbitrary type.  */
>  
>  static struct value *
> -ada_value_primitive_field (struct value *arg1, int offset, int fieldno,
> +ada_value_primitive_field (struct value *arg1, LONGEST offset, int fieldno,
>                             struct type *arg_type)
>  {
>    struct type *type;
> @@ -6439,12 +6442,13 @@ ada_value_primitive_field (struct value *arg1, int offset, int fieldno,
>  
>    if (TYPE_FIELD_BITSIZE (arg_type, fieldno) != 0)
>      {
> -      int bit_pos = TYPE_FIELD_BITPOS (arg_type, fieldno);
> +      LONGEST bit_pos = TYPE_FIELD_BITPOS (arg_type, fieldno);
>        int bit_size = TYPE_FIELD_BITSIZE (arg_type, fieldno);
>  
>        return ada_value_primitive_packed_val (arg1, value_contents (arg1),
> -                                             offset + bit_pos / 8,
> -                                             bit_pos % 8, bit_size, type);
> +					     offset + bit_pos / 8,
> +					     bit_pos % 8, bit_size,
> +					     type);

Only whitespace change (correct fix but not for this patch).


>      }
>    else
>      return value_primitive_field (arg1, offset, fieldno, arg_type);
> @@ -6466,9 +6470,9 @@ ada_value_primitive_field (struct value *arg1, int offset, int fieldno,
>     Returns 1 if found, 0 otherwise.  */
>  
>  static int
> -find_struct_field (const char *name, struct type *type, int offset,
> +find_struct_field (const char *name, struct type *type, LONGEST offset,
>                     struct type **field_type_p,
> -                   int *byte_offset_p, int *bit_offset_p, int *bit_size_p,
> +		   LONGEST *byte_offset_p, int *bit_offset_p, int *bit_size_p,
>  		   int *index_p)
>  {
>    int i;
> @@ -6486,8 +6490,8 @@ find_struct_field (const char *name, struct type *type, int offset,
>  
>    for (i = 0; i < TYPE_NFIELDS (type); i += 1)
>      {
> -      int bit_pos = TYPE_FIELD_BITPOS (type, i);
> -      int fld_offset = offset + bit_pos / 8;
> +      LONGEST bit_pos = TYPE_FIELD_BITPOS (type, i);
> +      LONGEST fld_offset = offset + bit_pos / 8;
>        const char *t_field_name = TYPE_FIELD_NAME (type, i);
>  
>        if (t_field_name == NULL)
> @@ -6557,7 +6561,7 @@ num_visible_fields (struct type *type)
>     Searches recursively through wrapper fields (e.g., '_parent').  */
>  
>  static struct value *
> -ada_search_struct_field (char *name, struct value *arg, int offset,
> +ada_search_struct_field (char *name, struct value *arg, LONGEST offset,
>                           struct type *type)
>  {
>    int i;
> @@ -6590,7 +6594,7 @@ ada_search_struct_field (char *name, struct value *arg, int offset,
>            int j;
>            struct type *field_type = ada_check_typedef (TYPE_FIELD_TYPE (type,
>  									i));
> -          int var_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
> +	  LONGEST var_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
>  
>            for (j = 0; j < TYPE_NFIELDS (field_type); j += 1)
>              {
> @@ -6608,8 +6612,8 @@ ada_search_struct_field (char *name, struct value *arg, int offset,
>    return NULL;
>  }
>  
> -static struct value *ada_index_struct_field_1 (int *, struct value *,
> -					       int, struct type *);
> +static struct value *ada_index_struct_field_1 (LONGEST *, struct value *,
> +					       LONGEST, struct type *);
>  
>  
>  /* Return field #INDEX in ARG, where the index is that returned by
> @@ -6618,7 +6622,7 @@ static struct value *ada_index_struct_field_1 (int *, struct value *,
>   * If found, return value, else return NULL.  */
>  
>  static struct value *
> -ada_index_struct_field (int index, struct value *arg, int offset,
> +ada_index_struct_field (LONGEST index, struct value *arg, LONGEST offset,
>  			struct type *type)
>  {
>    return ada_index_struct_field_1 (&index, arg, offset, type);
> @@ -6630,7 +6634,7 @@ ada_index_struct_field (int index, struct value *arg, int offset,
>   * *INDEX_P.  */
>  
>  static struct value *
> -ada_index_struct_field_1 (int *index_p, struct value *arg, int offset,
> +ada_index_struct_field_1 (LONGEST *index_p, struct value *arg, LONGEST offset,
>  			  struct type *type)
>  {
>    int i;
> @@ -6720,7 +6724,8 @@ ada_value_struct_elt (struct value *arg, char *name, int no_err)
>      v = ada_search_struct_field (name, arg, 0, t);
>    else
>      {
> -      int bit_offset, bit_size, byte_offset;
> +      int bit_offset, bit_size;
> +      LONGEST byte_offset;
>        struct type *field_type;
>        CORE_ADDR address;
>  
> @@ -7026,8 +7031,8 @@ ada_coerce_ref (struct value *val0)
>  /* Return OFF rounded upward if necessary to a multiple of
>     ALIGNMENT (a power of 2).  */
>  
> -static unsigned int
> -align_value (unsigned int off, unsigned int alignment)
> +static ULONGEST
> +align_value (LONGEST off, ULONGEST alignment)
X
>  {
>    return (off + alignment - 1) & ~(alignment - 1);
>  }
> @@ -7406,10 +7411,10 @@ ada_template_to_fixed_record_type_1 (struct type *type,
>    struct value *mark = value_mark ();
>    struct value *dval;
>    struct type *rtype;
> -  int nfields, bit_len;
> +  int nfields;
>    int variant_field;
> -  long off;
> -  int fld_bit_len;
> +  ULONGEST off, bit_len;
X
> +  ULONGEST fld_bit_len;
X
>    int f;
>  
>    /* Compute the number of fields in this record type that are going
> @@ -7480,7 +7485,7 @@ ada_template_to_fixed_record_type_1 (struct type *type,
>  	     that follow this one.  */
>  	  if (ada_is_aligner_type (field_type))
>  	    {
> -	      long field_offset = TYPE_FIELD_BITPOS (field_type, f);
> +	      LONGEST field_offset = TYPE_FIELD_BITPOS (field_type, f);
>  
>  	      field_valaddr = cond_offset_host (field_valaddr, field_offset);
>  	      field_address = cond_offset_target (field_address, field_offset);
> @@ -7599,11 +7604,11 @@ ada_template_to_fixed_record_type_1 (struct type *type,
>    if (TYPE_LENGTH (type) <= 0)
>      {
>        if (TYPE_NAME (rtype))
> -	warning (_("Invalid type size for `%s' detected: %d."),
> -		 TYPE_NAME (rtype), TYPE_LENGTH (type));
> +	warning (_("Invalid type size for `%s' detected: %s."),
> +		 TYPE_NAME (rtype), pulongest (TYPE_LENGTH (type)));
>        else
> -	warning (_("Invalid type size for <unnamed> detected: %d."),
> -		 TYPE_LENGTH (type));
> +	warning (_("Invalid type size for <unnamed> detected: %s."),
> +		 pulongest (TYPE_LENGTH (type)));
>      }
>    else
>      {
> @@ -7940,7 +7945,8 @@ to_fixed_array_type (struct type *type0, struct value *dval,
>  	 type was a regular (non-packed) array type.  As a result, the
>  	 bitsize of the array elements needs to be set again, and the array
>  	 length needs to be recomputed based on that bitsize.  */
> -      int len = TYPE_LENGTH (result) / TYPE_LENGTH (TYPE_TARGET_TYPE (result));
> +      ULONGEST len = TYPE_LENGTH (result) /
> +		     TYPE_LENGTH (TYPE_TARGET_TYPE (result));
X

Plus GNU Coding Standards Formatting should be:
      ULONGEST len = (TYPE_LENGTH (result)
		      / TYPE_LENGTH (TYPE_TARGET_TYPE (result)));


>        int elt_bitsize = TYPE_FIELD_BITSIZE (type0, 0);
>  
>        TYPE_FIELD_BITSIZE (result, 0) = TYPE_FIELD_BITSIZE (type0, 0);
> diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h
> index 9a93c50..3de0723 100644
> --- a/gdb/ada-lang.h
> +++ b/gdb/ada-lang.h
> @@ -168,7 +168,7 @@ extern void ada_print_type (struct type *, const char *, struct ui_file *, int,
>  extern void ada_print_typedef (struct type *type, struct symbol *new_symbol,
>  			       struct ui_file *stream);
>  
> -extern void ada_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
> +extern void ada_val_print (struct type *, const gdb_byte *, LONGEST, CORE_ADDR,
>  			   struct ui_file *, int,
>  			   const struct value *,
>  			   const struct value_print_options *);
> @@ -183,7 +183,7 @@ extern void ada_emit_char (int, struct type *, struct ui_file *, int, int);
>  extern void ada_printchar (int, struct type *, struct ui_file *);
>  
>  extern void ada_printstr (struct ui_file *, struct type *, const gdb_byte *,
> -			  unsigned int, const char *, int,
> +			  ULONGEST, const char *, int,
>  			  const struct value_print_options *);
>  
>  struct value *ada_convert_actual (struct value *actual,
> @@ -257,7 +257,7 @@ extern int ada_is_constrained_packed_array_type (struct type *);
>  
>  extern struct value *ada_value_primitive_packed_val (struct value *,
>  						     const gdb_byte *,
> -                                                     long, int, int,
> +						     LONGEST, int, int,
>                                                       struct type *);
>  
>  extern struct type *ada_coerce_to_simple_array_type (struct type *);
> diff --git a/gdb/ada-typeprint.c b/gdb/ada-typeprint.c
> index 40f3058..2a1852c 100644
> --- a/gdb/ada-typeprint.c
> +++ b/gdb/ada-typeprint.c
> @@ -815,8 +815,8 @@ ada_print_type (struct type *type0, const char *varstring,
>  	    const char *name = ada_type_name (type);
>  
>  	    if (!ada_is_range_type_name (name))
> -	      fprintf_filtered (stream, _("<%d-byte integer>"),
> -				TYPE_LENGTH (type));
> +	      fprintf_filtered (stream, _("<%s-byte integer>"),
> +				pulongest (TYPE_LENGTH (type)));
>  	    else
>  	      {
>  		fprintf_filtered (stream, "range ");
> @@ -837,7 +837,8 @@ ada_print_type (struct type *type0, const char *varstring,
>  	  }
>  	break;
>        case TYPE_CODE_FLT:
> -	fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
> +	fprintf_filtered (stream, _("<%s-byte float>"),
> +			  pulongest (TYPE_LENGTH (type)));
>  	break;
>        case TYPE_CODE_ENUM:
>  	if (show < 0)
> diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
> index 95ec7ec..245fd41 100644
> --- a/gdb/ada-valprint.c
> +++ b/gdb/ada-valprint.c
> @@ -42,19 +42,18 @@ static void print_record (struct type *, const gdb_byte *, int,
>  			  const struct value_print_options *);
>  
>  static int print_field_values (struct type *, const gdb_byte *,
> -			       int,
> +			       LONGEST,
>  			       struct ui_file *, int,
>  			       const struct value *,
>  			       const struct value_print_options *,
> -			       int, struct type *, int);
> +			       int, struct type *, LONGEST);
>  
>  static void adjust_type_signedness (struct type *);
>  
> -static void ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
> +static void ada_val_print_1 (struct type *, const gdb_byte *, LONGEST, CORE_ADDR,
>  			     struct ui_file *, int,
>  			     const struct value *,
>  			     const struct value_print_options *);

> -

Unrelated formatting change.


>  
>  /* Make TYPE unsigned if its range of values includes no negatives.  */
>  static void
> @@ -144,7 +143,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
>    unsigned int things_printed = 0;
>    unsigned len;
>    struct type *elttype, *index_type;
> -  unsigned eltlen;
> +  ULONGEST eltlen;
>    unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
>    struct value *mark = value_mark ();
>    LONGEST low = 0;
> @@ -293,7 +292,7 @@ ada_emit_char (int c, struct type *type, struct ui_file *stream,
>     of a character.  */
>  
>  static int
> -char_at (const gdb_byte *string, int i, int type_len,
> +char_at (const gdb_byte *string, ULONGEST i, int type_len,
X
>  	 enum bfd_endian byte_order)
>  {
>    if (type_len == 1)
> @@ -465,7 +464,7 @@ ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
>  
>  static void
>  printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,
> -	  unsigned int length, int force_ellipses, int type_len,
> +	  ULONGEST length, int force_ellipses, int type_len,
>  	  const struct value_print_options *options)
>  {
>    enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (elttype));
> @@ -556,7 +555,7 @@ printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,
>  
>  void
>  ada_printstr (struct ui_file *stream, struct type *type,
> -	      const gdb_byte *string, unsigned int length,
> +	      const gdb_byte *string, ULONGEST length,
>  	      const char *encoding, int force_ellipses,
>  	      const struct value_print_options *options)
>  {
> @@ -570,7 +569,7 @@ ada_printstr (struct ui_file *stream, struct type *type,
>  
>  void
>  ada_val_print (struct type *type, const gdb_byte *valaddr,
> -	       int embedded_offset, CORE_ADDR address,
> +	       LONGEST embedded_offset, CORE_ADDR address,
>  	       struct ui_file *stream, int recurse,
>  	       const struct value *val,
>  	       const struct value_print_options *options)
> @@ -602,8 +601,8 @@ ada_val_print_array (struct type *type, const gdb_byte *valaddr,
>      {
>        enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
>        struct type *elttype = TYPE_TARGET_TYPE (type);
> -      unsigned int eltlen;
> -      unsigned int len;
> +      ULONGEST eltlen;
> +      ULONGEST len;
>  
>        /* We know that ELTTYPE cannot possibly be null, because we found
>  	 that TYPE is a string-like type.  Similarly, the size of ELTTYPE
> @@ -621,7 +620,7 @@ ada_val_print_array (struct type *type, const gdb_byte *valaddr,
>           elements up to it.  */
>        if (options->stop_print_at_null)
>          {
> -          int temp_len;
> +          ULONGEST temp_len;
X
>  
>            /* Look for a NULL char.  */
>            for (temp_len = 0;
> @@ -654,7 +653,7 @@ ada_val_print_array (struct type *type, const gdb_byte *valaddr,
>  
>  static void
>  ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
> -		 int offset, CORE_ADDR address,
> +		 LONGEST offset, CORE_ADDR address,
>  		 struct ui_file *stream, int recurse,
>  		 const struct value *original_value,
>  		 const struct value_print_options *options)
> @@ -730,7 +729,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
>        if (ada_is_fixed_point_type (type))
>  	{
>  	  LONGEST v = unpack_long (type, valaddr + offset_aligned);
> -	  int len = TYPE_LENGTH (type);
> +	  ULONGEST len = TYPE_LENGTH (type);
X
>  
>  	  fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
>  			    (double) ada_fixed_to_float (type, v));
> @@ -924,12 +923,12 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
>  
>  static int
>  print_variant_part (struct type *type, int field_num,
> -		    const gdb_byte *valaddr, int offset,
> +		    const gdb_byte *valaddr, LONGEST offset,
>  		    struct ui_file *stream, int recurse,
>  		    const struct value *val,
>  		    const struct value_print_options *options,
>  		    int comma_needed,
> -		    struct type *outer_type, int outer_offset)
> +		    struct type *outer_type, LONGEST outer_offset)
>  {
>    struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
>    int which = ada_which_variant_applies (var_type, outer_type,
> @@ -1036,11 +1035,11 @@ print_record (struct type *type, const gdb_byte *valaddr,
>  
>  static int
>  print_field_values (struct type *type, const gdb_byte *valaddr,
> -		    int offset, struct ui_file *stream, int recurse,
> +		    LONGEST offset, struct ui_file *stream, int recurse,
>  		    const struct value *val,
>  		    const struct value_print_options *options,
>  		    int comma_needed,
> -		    struct type *outer_type, int outer_offset)
> +		    struct type *outer_type, LONGEST outer_offset)
>  {
>    int i, len;
>  
> @@ -1121,7 +1120,7 @@ print_field_values (struct type *type, const gdb_byte *valaddr,
>  	    }
>  	  else
>  	    {
> -	      int bit_pos = TYPE_FIELD_BITPOS (type, i);
> +	      LONGEST bit_pos = TYPE_FIELD_BITPOS (type, i);
>  	      int bit_size = TYPE_FIELD_BITSIZE (type, i);
>  	      struct value_print_options opts;
>  
> diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c
> index 856aa0d..8b6a970 100644
> --- a/gdb/alpha-tdep.c
> +++ b/gdb/alpha-tdep.c
> @@ -303,7 +303,7 @@ alpha_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    struct alpha_arg
>      {
>        const gdb_byte *contents;
> -      int len;
> +      ULONGEST len;
X
>        int offset;
>      };
>    struct alpha_arg *alpha_args
> @@ -424,7 +424,7 @@ alpha_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>      {
>        const gdb_byte *contents = m_arg->contents;
>        int offset = m_arg->offset;
> -      int len = m_arg->len;
> +      ULONGEST len = m_arg->len;
X
>  
>        /* Copy the bytes destined for registers into arg_reg_buffer.  */
>        if (offset < sizeof(arg_reg_buffer))
> @@ -475,7 +475,7 @@ alpha_extract_return_value (struct type *valtype, struct regcache *regcache,
>  {
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
> -  int length = TYPE_LENGTH (valtype);
> +  ULONGEST length = TYPE_LENGTH (valtype);
X
>    gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
>    ULONGEST l;
>  
> @@ -544,7 +544,7 @@ alpha_store_return_value (struct type *valtype, struct regcache *regcache,
>  			  const gdb_byte *valbuf)
>  {
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
> -  int length = TYPE_LENGTH (valtype);
> +  ULONGEST length = TYPE_LENGTH (valtype);
X
>    gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
>    ULONGEST l;
>  
> diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c
> index 685fa48..0ec7f99 100644
> --- a/gdb/amd64-tdep.c
> +++ b/gdb/amd64-tdep.c
> @@ -443,7 +443,7 @@ amd64_non_pod_p (struct type *type)
>  static void
>  amd64_classify_aggregate (struct type *type, enum amd64_reg_class class[2])
>  {
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    /* 1. If the size of an object is larger than two eightbytes, or in
>          C++, is a non-POD structure or union type, or contains
> @@ -482,10 +482,10 @@ amd64_classify_aggregate (struct type *type, enum amd64_reg_class class[2])
>        for (i = 0; i < TYPE_NFIELDS (type); i++)
>  	{
>  	  struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
> -	  int pos = TYPE_FIELD_BITPOS (type, i) / 64;
> +	  LONGEST pos = TYPE_FIELD_BITPOS (type, i) / 64;
>  	  enum amd64_reg_class subclass[2];
> -	  int bitsize = TYPE_FIELD_BITSIZE (type, i);
> -	  int endpos;
> +	  ULONGEST bitsize = TYPE_FIELD_BITSIZE (type, i);
X
> +	  LONGEST endpos;
>  
>  	  if (bitsize == 0)
>  	    bitsize = TYPE_LENGTH (subtype) * 8;
> @@ -549,7 +549,7 @@ void
>  amd64_classify (struct type *type, enum amd64_reg_class class[2])
>  {
>    enum type_code code = TYPE_CODE (type);
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    class[0] = class[1] = AMD64_NO_CLASS;
>  
> @@ -598,7 +598,7 @@ amd64_return_value (struct gdbarch *gdbarch, struct type *func_type,
>  {
>    struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
>    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;
> @@ -727,8 +727,8 @@ amd64_push_arguments (struct regcache *regcache, int nargs,
>       that register number (or a negative value otherwise).  */
>    int *arg_addr_regno = alloca (nargs * sizeof (int));
>    int num_stack_args = 0;
> -  int num_elements = 0;
> -  int element = 0;
> +  ULONGEST num_elements = 0;
X
> +  ULONGEST element = 0;
X
>    int integer_reg = 0;
>    int sse_reg = 0;
>    int i;
> @@ -742,7 +742,7 @@ amd64_push_arguments (struct regcache *regcache, int nargs,
>    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;
> @@ -836,7 +836,7 @@ amd64_push_arguments (struct regcache *regcache, int nargs,
>      {
>        struct type *type = value_type (stack_args[i]);
>        const gdb_byte *valbuf = value_contents (stack_args[i]);
> -      int len = TYPE_LENGTH (type);
> +      ULONGEST len = TYPE_LENGTH (type);
X
>        CORE_ADDR arg_addr = sp + element * 8;
>  
>        write_memory (arg_addr, valbuf, len);
> @@ -2551,7 +2551,7 @@ amd64_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
>    CORE_ADDR jb_addr;
>    struct gdbarch *gdbarch = get_frame_arch (frame);
>    int jb_pc_offset = gdbarch_tdep (gdbarch)->jb_pc_offset;
> -  int len = TYPE_LENGTH (builtin_type (gdbarch)->builtin_func_ptr);
> +  ULONGEST len = TYPE_LENGTH (builtin_type (gdbarch)->builtin_func_ptr);
X
>  
>    /* If JB_PC_OFFSET is -1, we have no way to find out where the
>       longjmp will land.	 */
> diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c
> index 2b94eca..2ec936c 100644
> --- a/gdb/amd64-windows-tdep.c
> +++ b/gdb/amd64-windows-tdep.c
> @@ -77,7 +77,7 @@ amd64_windows_return_value (struct gdbarch *gdbarch, struct type *func_type,
>  			    struct type *type, struct regcache *regcache,
>  			    gdb_byte *readbuf, const gdb_byte *writebuf)
>  {
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>    int regnum = -1;
>  
>    /* See if our value is returned through a register.  If it is, then
> diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
> index f83dc0e..51eed0c 100644
> --- a/gdb/arm-tdep.c
> +++ b/gdb/arm-tdep.c
> @@ -3577,7 +3577,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>  
>    for (argnum = 0; argnum < nargs; argnum++)
>      {
> -      int len;
> +      ULONGEST len;
X
>        struct type *arg_type;
>        struct type *target_type;
>        enum type_code typecode;
> @@ -8773,7 +8773,7 @@ arm_extract_return_value (struct type *type, struct regcache *regs,
>        /* If the type is a plain integer, then the access is
>  	 straight-forward.  Otherwise we have to play around a bit
>  	 more.  */
> -      int len = TYPE_LENGTH (type);
> +      LONGEST len = TYPE_LENGTH (type);
>        int regno = ARM_A1_REGNUM;
>        ULONGEST tmp;
>  
> @@ -8795,7 +8795,7 @@ arm_extract_return_value (struct type *type, struct regcache *regs,
>        /* For a structure or union the behaviour is as if the value had
>           been stored to word-aligned memory and then loaded into 
>           registers with 32-bit load instruction(s).  */
> -      int len = TYPE_LENGTH (type);
> +      LONGEST len = TYPE_LENGTH (type);
>        int regno = ARM_A1_REGNUM;
>        bfd_byte tmpbuf[INT_REGISTER_SIZE];
>  
> @@ -8976,7 +8976,7 @@ arm_store_return_value (struct type *type, struct regcache *regs,
>  	  /* Integral values greater than one word are stored in consecutive
>  	     registers starting with r0.  This will always be a multiple of
>  	     the regiser size.  */
> -	  int len = TYPE_LENGTH (type);
> +	  LONGEST len = TYPE_LENGTH (type);
>  	  int regno = ARM_A1_REGNUM;
>  
>  	  while (len > 0)
> @@ -8992,7 +8992,7 @@ arm_store_return_value (struct type *type, struct regcache *regs,
>        /* For a structure or union the behaviour is as if the value had
>           been stored to word-aligned memory and then loaded into 
>           registers with 32-bit load instruction(s).  */
> -      int len = TYPE_LENGTH (type);
> +      LONGEST len = TYPE_LENGTH (type);
>        int regno = ARM_A1_REGNUM;
>        bfd_byte tmpbuf[INT_REGISTER_SIZE];
>  
> diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c
> index 34b0baf..c7ba3d8 100644
> --- a/gdb/avr-tdep.c
> +++ b/gdb/avr-tdep.c
> @@ -906,7 +906,7 @@ avr_return_value (struct gdbarch *gdbarch, struct type *func_type,
>  		  struct type *valtype, struct regcache *regcache,
>  		  gdb_byte *readbuf, const gdb_byte *writebuf)
>  {
> -  int i;
> +  ULONGEST i;
X
>    /* Single byte are returned in r24.
>       Otherwise, the MSB of the return value is always in r25, calculate which
>       register holds the LSB.  */
> @@ -1177,7 +1177,8 @@ struct stack_item
>  };
>  
>  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,
> +		 ULONGEST len)
X
>  {
>    struct stack_item *si;
>    si = xmalloc (sizeof (struct stack_item));
> @@ -1266,12 +1267,12 @@ avr_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>  
>    for (i = 0; i < nargs; i++)
>      {
> -      int last_regnum;
> +      ULONGEST last_regnum;
X
>        int 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);
> +      ULONGEST len = TYPE_LENGTH (type);
X
>  
>        /* Calculate the potential last register needed.  */
>        last_regnum = regnum - (len + (len & 1));
> diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
> index 909f282..b1b8071 100644
> --- a/gdb/ax-gdb.c
> +++ b/gdb/ax-gdb.c
> @@ -80,12 +80,12 @@ static void gen_traced_pop (struct gdbarch *, struct agent_expr *,
>  static void gen_sign_extend (struct agent_expr *, struct type *);
>  static void gen_extend (struct agent_expr *, struct type *);
>  static void gen_fetch (struct agent_expr *, struct type *);
> -static void gen_left_shift (struct agent_expr *, int);
> +static void gen_left_shift (struct agent_expr *, LONGEST);
>  
>  
>  static void gen_frame_args_address (struct gdbarch *, struct agent_expr *);
>  static void gen_frame_locals_address (struct gdbarch *, struct agent_expr *);
> -static void gen_offset (struct agent_expr *ax, int offset);
> +static void gen_offset (struct agent_expr *ax, LONGEST offset);
>  static void gen_sym_offset (struct agent_expr *, struct symbol *);
>  static void gen_var_ref (struct gdbarch *, struct agent_expr *ax,
>  			 struct axs_value *value, struct symbol *var);
> @@ -133,15 +133,16 @@ static void gen_deref (struct agent_expr *, struct axs_value *);
>  static void gen_address_of (struct agent_expr *, struct axs_value *);
>  static void gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
>  			      struct axs_value *value,
> -			      struct type *type, int start, int end);
> +			      struct type *type, LONGEST start, LONGEST end);
>  static void gen_primitive_field (struct expression *exp,
>  				 struct agent_expr *ax,
>  				 struct axs_value *value,
> -				 int offset, int fieldno, struct type *type);
> +				 LONGEST offset, int fieldno,
> +				 struct type *type);
>  static int gen_struct_ref_recursive (struct expression *exp,
>  				     struct agent_expr *ax,
>  				     struct axs_value *value,
> -				     char *field, int offset,
> +				     char *field, LONGEST offset,
>  				     struct type *type);
>  static void gen_struct_ref (struct expression *exp, struct agent_expr *ax,
>  			    struct axs_value *value,
> @@ -363,7 +364,7 @@ gen_trace_static_fields (struct gdbarch *gdbarch,
>  	    {
>  	    case axs_lvalue_memory:
>  	      {
> -		int length = TYPE_LENGTH (check_typedef (value.type));
> +		ULONGEST length = TYPE_LENGTH (check_typedef (value.type));
X
>  
>  		ax_const_l (ax, length);
>  		ax_simple (ax, aop_trace);
> @@ -421,7 +422,7 @@ gen_traced_pop (struct gdbarch *gdbarch,
>  
>        case axs_lvalue_memory:
>  	{
> -	  int length = TYPE_LENGTH (check_typedef (value->type));
> +	  ULONGEST length = TYPE_LENGTH (check_typedef (value->type));
X
>  
>  	  if (string_trace)
>  	    ax_simple (ax, aop_dup);
> @@ -565,7 +566,7 @@ gen_fetch (struct agent_expr *ax, struct type *type)
>     right shift it by -DISTANCE bits if DISTANCE < 0.  This generates
>     unsigned (logical) right shifts.  */
>  static void
> -gen_left_shift (struct agent_expr *ax, int distance)
> +gen_left_shift (struct agent_expr *ax, LONGEST distance)
>  {
>    if (distance > 0)
>      {
> @@ -619,7 +620,7 @@ gen_frame_locals_address (struct gdbarch *gdbarch, struct agent_expr *ax)
>     programming in ML, it would be clearer why these are the same
>     thing.  */
>  static void
> -gen_offset (struct agent_expr *ax, int offset)
> +gen_offset (struct agent_expr *ax, LONGEST offset)
>  {
>    /* It would suffice to simply push the offset and add it, but this
>       makes it easier to read positive and negative offsets in the
> @@ -1275,7 +1276,7 @@ gen_address_of (struct agent_expr *ax, struct axs_value *value)
>  static void
>  gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
>  		  struct axs_value *value, struct type *type,
> -		  int start, int end)
> +		  LONGEST start, LONGEST end)
>  {
>    /* Note that ops[i] fetches 8 << i bits.  */
>    static enum agent_op ops[]
> @@ -1310,13 +1311,13 @@ gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
>  
>    /* The first and one-after-last bits in the field, but rounded down
>       and up to byte boundaries.  */
> -  int bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT;
> -  int bound_end = (((end + TARGET_CHAR_BIT - 1)
> -		    / TARGET_CHAR_BIT)
> -		   * TARGET_CHAR_BIT);
> +  LONGEST bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT;
> +  LONGEST bound_end = (((end + TARGET_CHAR_BIT - 1)
> +			/ TARGET_CHAR_BIT)
> +		       * TARGET_CHAR_BIT);
>  
>    /* current bit offset within the structure */
> -  int offset;
> +  LONGEST offset;
>  
>    /* The index in ops of the opcode we're considering.  */
>    int op;
> @@ -1435,7 +1436,7 @@ gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
>  static void
>  gen_primitive_field (struct expression *exp,
>  		     struct agent_expr *ax, struct axs_value *value,
> -		     int offset, int fieldno, struct type *type)
> +		     LONGEST offset, int fieldno, struct type *type)
>  {
>    /* Is this a bitfield?  */
>    if (TYPE_FIELD_PACKED (type, fieldno))
> @@ -1460,7 +1461,7 @@ gen_primitive_field (struct expression *exp,
>  static int
>  gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
>  			  struct axs_value *value,
> -			  char *field, int offset, struct type *type)
> +			  char *field, LONGEST offset, struct type *type)
>  {
>    int i, rslt;
>    int nbases = TYPE_N_BASECLASSES (type);
> diff --git a/gdb/bfin-tdep.c b/gdb/bfin-tdep.c
> index a48758d..e5eef86 100644
> --- a/gdb/bfin-tdep.c
> +++ b/gdb/bfin-tdep.c
> @@ -506,14 +506,14 @@ bfin_push_dummy_call (struct gdbarch *gdbarch,
>    char buf[4];
>    int i;
>    long reg_r0, reg_r1, reg_r2;
> -  int total_len = 0;
> +  ULONGEST total_len = 0;
X
>    enum bfin_abi abi = bfin_abi (gdbarch);
>    CORE_ADDR func_addr = find_function_addr (function, NULL);
>  
>    for (i = nargs - 1; i >= 0; i--)
>      {
>        struct type *value_type = value_enclosing_type (args[i]);
> -      int len = TYPE_LENGTH (value_type);
> +      ULONGEST len = TYPE_LENGTH (value_type);
X
>  
>        total_len += (len + 3) & ~3;
>      }
> @@ -531,8 +531,8 @@ bfin_push_dummy_call (struct gdbarch *gdbarch,
>      {
>        struct type *value_type = value_enclosing_type (args[i]);
>        struct type *arg_type = check_typedef (value_type);
> -      int len = TYPE_LENGTH (value_type);
> -      int container_len = (len + 3) & ~3;
> +      ULONGEST len = TYPE_LENGTH (value_type);
X
> +      ULONGEST container_len = (len + 3) & ~3;
X
>  
>        sp -= container_len;
>        write_memory (sp, value_contents_writeable (args[i]), container_len);
> @@ -613,7 +613,7 @@ bfin_extract_return_value (struct type *type,
>    struct gdbarch *gdbarch = get_regcache_arch (regs);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    bfd_byte *valbuf = dst;
> -  int len = TYPE_LENGTH (type);
> +  LONGEST len = TYPE_LENGTH (type);
>    ULONGEST tmp;
>    int regno = BFIN_R0_REGNUM;
>  
> @@ -642,7 +642,7 @@ bfin_store_return_value (struct type *type,
>       registers starting with R0.  This will always be a multiple of
>       the register size.  */
>  
> -  int len = TYPE_LENGTH (type);
> +  LONGEST len = TYPE_LENGTH (type);
>    int regno = BFIN_R0_REGNUM;
>  
>    gdb_assert (len <= 8);
> diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
> index ab5f324..0e61513 100644
> --- a/gdb/breakpoint.c
> +++ b/gdb/breakpoint.c
> @@ -1747,7 +1747,8 @@ update_watchpoint (struct watchpoint *b, int reparse)
>  		      && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
>  		{
>  		  CORE_ADDR addr;
> -		  int len, type;
> +		  ULONGEST len;
X
> +		  int type;
>  		  struct bp_location *loc, **tmp;
>  
>  		  addr = value_address (v);
> @@ -10495,7 +10496,7 @@ can_use_hardware_watchpoint (struct value *v)
>  		      && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
>  		{
>  		  CORE_ADDR vaddr = value_address (v);
> -		  int len;
> +		  ULONGEST len;
X
>  		  int num_regs;
>  
>  		  len = (target_exact_watchpoints
> @@ -14091,7 +14092,7 @@ show_breakpoint_cmd (char *args, int from_tty)
>     GDB itself.  */
>  
>  static void
> -invalidate_bp_value_on_memory_change (CORE_ADDR addr, int len,
> +invalidate_bp_value_on_memory_change (CORE_ADDR addr, LONGEST len,
>  				      const bfd_byte *data)
>  {
>    struct breakpoint *bp;
> diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
> index d23561a..152aaad 100644
> --- a/gdb/breakpoint.h
> +++ b/gdb/breakpoint.h
> @@ -400,7 +400,7 @@ struct bp_location
>    /* For hardware watchpoints, the size of the memory region being
>       watched.  For hardware ranged breakpoints, the size of the
>       breakpoint range.  */
> -  int length;
> +  ULONGEST length;
X
>  
>    /* Type of hardware watchpoint.  */
>    enum target_hw_bp_type watchpoint_type;
> diff --git a/gdb/c-lang.c b/gdb/c-lang.c
> index 28dce8d..2064011 100644
> --- a/gdb/c-lang.c
> +++ b/gdb/c-lang.c
> @@ -189,7 +189,7 @@ c_printchar (int c, struct type *type, struct ui_file *stream)
>  
>  void
>  c_printstr (struct ui_file *stream, struct type *type, 
> -	    const gdb_byte *string, unsigned int length, 
> +	    const gdb_byte *string, ULONGEST length,
>  	    const char *user_encoding, int force_ellipses,
>  	    const struct value_print_options *options)
>  {
> @@ -202,7 +202,6 @@ c_printstr (struct ui_file *stream, struct type *type,
>    unsigned int things_printed = 0;
>    int in_quotes = 0;
>    int need_comma = 0;
> -  int width = TYPE_LENGTH (type);

This should be a separate patch, unrelated to this one.  Obvious for commit.


>    struct obstack wchar_buf, output;
>    struct cleanup *cleanup;
>    struct wchar_iterator *iter;
> @@ -679,7 +678,7 @@ evaluate_subexp_c (struct type *expect_type, struct expression *exp,
>  	  }
>  	else
>  	  {
> -	    int i;
> +	    ULONGEST i;
X
>  
>  	    /* Write the terminating character.  */
>  	    for (i = 0; i < TYPE_LENGTH (type); ++i)
> @@ -688,7 +687,7 @@ evaluate_subexp_c (struct type *expect_type, struct expression *exp,
>  	    if (satisfy_expected)
>  	      {
>  		LONGEST low_bound, high_bound;
> -		int element_size = TYPE_LENGTH (type);
> +		ULONGEST element_size = TYPE_LENGTH (type);
X
>  
>  		if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
>  					 &low_bound, &high_bound) < 0)
> diff --git a/gdb/c-lang.h b/gdb/c-lang.h
> index 5cbe34d..c02b8f4 100644
> --- a/gdb/c-lang.h
> +++ b/gdb/c-lang.h
> @@ -72,7 +72,7 @@ extern void c_print_typedef (struct type *,
>  			     struct ui_file *);
>  
>  extern void c_val_print (struct type *, const gdb_byte *,
> -			 int, CORE_ADDR,
> +			 LONGEST, CORE_ADDR,
>  			 struct ui_file *, int,
>  			 const struct value *,
>  			 const struct value_print_options *);
> @@ -92,7 +92,7 @@ extern void c_printchar (int, struct type *, struct ui_file *);
>  extern void c_printstr (struct ui_file * stream,
>  			struct type *elttype,
>  			const gdb_byte *string,
> -			unsigned int length,
> +			ULONGEST length,
>  			const char *user_encoding,
>  			int force_ellipses,
>  			const struct value_print_options *options);
> @@ -118,14 +118,14 @@ extern void cp_print_class_member (const gdb_byte *, struct type *,
>  				   struct ui_file *, char *);
>  
>  extern void cp_print_value_fields (struct type *, struct type *,
> -				   const gdb_byte *, int, CORE_ADDR,
> +				   const gdb_byte *, LONGEST, CORE_ADDR,
>  				   struct ui_file *, int,
>  				   const struct value *,
>  				   const struct value_print_options *,
>  				   struct type **, int);
>  
>  extern void cp_print_value_fields_rtti (struct type *,
> -					const gdb_byte *, int, CORE_ADDR,
> +					const gdb_byte *, LONGEST, CORE_ADDR,
>  					struct ui_file *, int,
>  					const struct value *,
>  					const struct value_print_options *,
> diff --git a/gdb/c-typeprint.c b/gdb/c-typeprint.c
> index a5892b5..1fd6b48 100644
> --- a/gdb/c-typeprint.c
> +++ b/gdb/c-typeprint.c
> @@ -625,8 +625,8 @@ c_type_print_varspec_suffix (struct type *type,
>  
>  	fprintf_filtered (stream, "[");
>  	if (get_array_bounds (type, &low_bound, &high_bound))
> -	  fprintf_filtered (stream, "%d", 
> -			    (int) (high_bound - low_bound + 1));
> +	  fprintf_filtered (stream, "%s", 
> +			    pulongest (high_bound - low_bound + 1));

To keep with the signedness use plongest.


>  	fprintf_filtered (stream, "]");
>  
>  	c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
> diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
> index d1fd56d..620bde4 100644
> --- a/gdb/c-valprint.c
> +++ b/gdb/c-valprint.c
> @@ -133,7 +133,7 @@ static const struct generic_val_print_decorations c_decorations =
>  
>  void
>  c_val_print (struct type *type, const gdb_byte *valaddr,
> -	     int embedded_offset, CORE_ADDR address,
> +	     LONGEST embedded_offset, CORE_ADDR address,
>  	     struct ui_file *stream, int recurse,
>  	     const struct value *original_value,
>  	     const struct value_print_options *options)
> @@ -144,7 +144,7 @@ c_val_print (struct type *type, const gdb_byte *valaddr,
>    unsigned len;
>    struct type *elttype, *unresolved_elttype;
>    struct type *unresolved_type = type;
> -  unsigned eltlen;
> +  ULONGEST eltlen;
>    LONGEST val;
>    CORE_ADDR addr;
>  
> @@ -346,9 +346,9 @@ c_val_print (struct type *type, const gdb_byte *valaddr,
>  	  /* Print vtable entry - we only get here if NOT using
>  	     -fvtable_thunks.  (Otherwise, look under
>  	     TYPE_CODE_PTR.)  */
> -	  int offset = (embedded_offset
> -			+ TYPE_FIELD_BITPOS (type,
> -					     VTBL_FNADDR_OFFSET) / 8);
> +	  LONGEST offset = (embedded_offset
> +			    + TYPE_FIELD_BITPOS (type,
> +					 	 VTBL_FNADDR_OFFSET) / 8);
>  	  struct type *field_type = TYPE_FIELD_TYPE (type,
>  						     VTBL_FNADDR_OFFSET);
>  	  CORE_ADDR addr
> @@ -428,7 +428,8 @@ c_value_print (struct value *val, struct ui_file *stream,
>  	       const struct value_print_options *options)
>  {
>    struct type *type, *real_type, *val_type;
> -  int full, top, using_enc;
> +  int full, using_enc;
> +  LONGEST top;
>    struct value_print_options opts = *options;
>  
>    opts.deref_ref = 1;
> diff --git a/gdb/corefile.c b/gdb/corefile.c
> index 986e4f5..ff15eac 100644
> --- a/gdb/corefile.c
> +++ b/gdb/corefile.c
> @@ -213,7 +213,7 @@ memory_error (int status, CORE_ADDR memaddr)
>  /* Same as target_read_memory, but report an error if can't read.  */
>  
>  void
> -read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
> +read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len)
X
>  {
>    int status;
>  
> @@ -225,7 +225,7 @@ read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
>  /* Same as target_read_stack, but report an error if can't read.  */
>  
>  void
> -read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
> +read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len)
X
>  {
>    int status;
>  
> @@ -352,7 +352,7 @@ read_memory_typed_address (CORE_ADDR addr, struct type *type)
>     write.  */
>  void
>  write_memory (CORE_ADDR memaddr, 
> -	      const bfd_byte *myaddr, int len)
> +	      const bfd_byte *myaddr, ULONGEST len)
X
>  {
>    int status;
>  
> diff --git a/gdb/cp-abi.c b/gdb/cp-abi.c
> index 16b5356..03f4baf 100644
> --- a/gdb/cp-abi.c
> +++ b/gdb/cp-abi.c
> @@ -68,13 +68,13 @@ is_operator_name (const char *name)
>    return (*current_cp_abi.is_operator_name) (name);
>  }
>  
> -int
> +LONGEST
>  baseclass_offset (struct type *type, int index, const gdb_byte *valaddr,
> -		  int embedded_offset, CORE_ADDR address,
> +		  LONGEST embedded_offset, CORE_ADDR address,
>  		  const struct value *val)
>  {
>    volatile struct gdb_exception ex;
> -  int res = 0;
> +  LONGEST res = 0;
>  
>    gdb_assert (current_cp_abi.baseclass_offset != NULL);
>  
> @@ -98,7 +98,7 @@ baseclass_offset (struct type *type, int index, const gdb_byte *valaddr,
>  struct value *
>  value_virtual_fn_field (struct value **arg1p,
>  			struct fn_field *f, int j,
> -			struct type *type, int offset)
> +			struct type *type, LONGEST offset)
>  {
>    if ((current_cp_abi.virtual_fn_field) == NULL)
>      return NULL;
> @@ -108,7 +108,7 @@ value_virtual_fn_field (struct value **arg1p,
>  
>  struct type *
>  value_rtti_type (struct value *v, int *full,
> -		 int *top, int *using_enc)
> +		 LONGEST *top, int *using_enc)
>  {
>    struct type *ret = NULL;
>    volatile struct gdb_exception e;
> diff --git a/gdb/cp-abi.h b/gdb/cp-abi.h
> index 8451450..a34e9fe 100644
> --- a/gdb/cp-abi.h
> +++ b/gdb/cp-abi.h
> @@ -108,7 +108,7 @@ extern struct value *value_virtual_fn_field (struct value **valuep,
>  					     struct fn_field *f,
>  					     int j,
>  					     struct type *type,
> -					     int offset);
> +					     LONGEST offset);
>  
>  
>  /* Try to find the run-time type of VALUE, using C++ run-time type
> @@ -135,7 +135,7 @@ extern struct value *value_virtual_fn_field (struct value **valuep,
>     FULL, TOP, and USING_ENC can each be zero, in which case we don't
>     provide the corresponding piece of information.  */
>  extern struct type *value_rtti_type (struct value *value,
> -                                     int *full, int *top,
> +                                     int *full, LONGEST *top,
>  				     int *using_enc);
>  
>  /* Compute the offset of the baseclass which is the INDEXth baseclass
> @@ -144,11 +144,11 @@ extern struct type *value_rtti_type (struct value *value,
>     contents of VAL.  The result is the offset of the baseclass value
>     relative to (the address of)(ARG) + OFFSET.  */
>  
> -extern int baseclass_offset (struct type *type,
> -			     int index, const gdb_byte *valaddr,
> -			     int embedded_offset,
> -			     CORE_ADDR address,
> -			     const struct value *val);
> +extern LONGEST baseclass_offset (struct type *type,
> +				 int index, const gdb_byte *valaddr,
> +				 LONGEST embedded_offset,
> +				 CORE_ADDR address,
> +				 const struct value *val);
>  
>  /* Describe the target of a pointer to method.  CONTENTS is the byte
>     pattern representing the pointer to method.  TYPE is the pointer to
> @@ -204,12 +204,13 @@ struct cp_abi_ops
>    struct value *(*virtual_fn_field) (struct value **arg1p,
>  				     struct fn_field * f,
>  				     int j, struct type * type,
> -				     int offset);
> +				     LONGEST offset);
>    struct type *(*rtti_type) (struct value *v, int *full,
> -			     int *top, int *using_enc);
> -  int (*baseclass_offset) (struct type *type, int index,
> -			   const bfd_byte *valaddr, int embedded_offset,
> -			   CORE_ADDR address, const struct value *val);
> +			     LONGEST *top, int *using_enc);
> +  LONGEST (*baseclass_offset) (struct type *type, int index,
> +			       const bfd_byte *valaddr,
> +			       LONGEST embedded_offset, CORE_ADDR address,
> +			       const struct value *val);
>    void (*print_method_ptr) (const gdb_byte *contents,
>  			    struct type *type,
>  			    struct ui_file *stream);
> diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c
> index 7dd13bb..a7b9381 100644
> --- a/gdb/cp-valprint.c
> +++ b/gdb/cp-valprint.c
> @@ -82,7 +82,7 @@ static void cp_print_static_field (struct type *, struct value *,
>  				   const struct value_print_options *);
>  
>  static void cp_print_value (struct type *, struct type *,
> -			    const gdb_byte *, int,
> +			    const gdb_byte *, LONGEST,
>  			    CORE_ADDR, struct ui_file *,
>  			    int, const struct value *,
>  			    const struct value_print_options *,
> @@ -156,7 +156,7 @@ cp_is_vtbl_member (struct type *type)
>  
>  void
>  cp_print_value_fields (struct type *type, struct type *real_type,
> -		       const gdb_byte *valaddr, int offset,
> +		       const gdb_byte *valaddr, LONGEST offset,
>  		       CORE_ADDR address, struct ui_file *stream,
>  		       int recurse, const struct value *val,
>  		       const struct value_print_options *options,
> @@ -443,7 +443,7 @@ cp_print_value_fields (struct type *type, struct type *real_type,
>  
>  void
>  cp_print_value_fields_rtti (struct type *type,
> -			    const gdb_byte *valaddr, int offset,
> +			    const gdb_byte *valaddr, LONGEST offset,
>  			    CORE_ADDR address,
>  			    struct ui_file *stream, int recurse,
>  			    const struct value *val,
> @@ -459,7 +459,8 @@ cp_print_value_fields_rtti (struct type *type,
>  			TARGET_CHAR_BIT * TYPE_LENGTH (type)))
>      {
>        struct value *value;
> -      int full, top, using_enc;
> +      int full, using_enc;
> +      LONGEST top;
>  
>        /* Ugh, we have to convert back to a value here.  */
>        value = value_from_contents_and_address (type, valaddr + offset,
> @@ -483,7 +484,7 @@ cp_print_value_fields_rtti (struct type *type,
>  
>  static void
>  cp_print_value (struct type *type, struct type *real_type,
> -		const gdb_byte *valaddr, int offset,
> +		const gdb_byte *valaddr, LONGEST offset,
>  		CORE_ADDR address, struct ui_file *stream,
>  		int recurse, const struct value *val,
>  		const struct value_print_options *options,
> @@ -493,7 +494,7 @@ cp_print_value (struct type *type, struct type *real_type,
>      = (struct type **) obstack_next_free (&dont_print_vb_obstack);
>    struct obstack tmp_obstack = dont_print_vb_obstack;
>    int i, n_baseclasses = TYPE_N_BASECLASSES (type);
> -  int thisoffset;
> +  LONGEST thisoffset;
>    struct type *thistype;
>  
>    if (dont_print_vb == 0)
> @@ -507,7 +508,7 @@ cp_print_value (struct type *type, struct type *real_type,
>  
>    for (i = 0; i < n_baseclasses; i++)
>      {
> -      int boffset = 0;
> +      LONGEST boffset = 0;
>        int skip;
>        struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
>        const char *basename = TYPE_NAME (baseclass);
> @@ -759,7 +760,7 @@ cp_find_class_member (struct type **domain_p, int *fieldno,
>    for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
>      {
>        LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
> -      LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i));
> +      ULONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i));
X
In fact redundant for this patch.


>  
>        if (offset >= bitpos && offset < bitpos + bitsize)
>  	{
> diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c
> index 34a2594..a0a6734 100644
> --- a/gdb/cris-tdep.c
> +++ b/gdb/cris-tdep.c
> @@ -678,7 +678,7 @@ struct stack_item
>  };
>  
>  static struct stack_item *
> -push_stack_item (struct stack_item *prev, void *contents, int len)
> +push_stack_item (struct stack_item *prev, void *contents, ULONGEST len)
X
>  {
>    struct stack_item *si;
>    si = xmalloc (sizeof (struct stack_item));
> @@ -856,10 +856,10 @@ cris_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>  
>    for (argnum = 0; argnum < nargs; argnum++)
>      {
> -      int len;
> +      ULONGEST len;
X
>        char *val;
> -      int reg_demand;
> -      int i;
> +      ULONGEST reg_demand;
X
> +      ULONGEST i;
X
>        
>        len = TYPE_LENGTH (value_type (args[argnum]));
>        val = (char *) value_contents (args[argnum]);
> @@ -1669,7 +1669,7 @@ cris_store_return_value (struct type *type, struct regcache *regcache,
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    ULONGEST val;
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>    
>    if (len <= 4)
>      {
> @@ -1840,7 +1840,7 @@ cris_extract_return_value (struct type *type, struct regcache *regcache,
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    ULONGEST val;
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>    
>    if (len <= 4)
>      {
> diff --git a/gdb/d-lang.h b/gdb/d-lang.h
> index f93405a..84b149f 100644
> --- a/gdb/d-lang.h
> +++ b/gdb/d-lang.h
> @@ -25,7 +25,7 @@
>  extern char *d_demangle (const char *mangled, int options);
>  
>  extern void d_val_print (struct type *type, const gdb_byte *valaddr,
> -			 int embedded_offset, CORE_ADDR address,
> +			 LONGEST embedded_offset, CORE_ADDR address,
>  			 struct ui_file *stream, int recurse,
>  			 const struct value *val,
>  			 const struct value_print_options *options);
> diff --git a/gdb/d-valprint.c b/gdb/d-valprint.c
> index 3a8d11d..5d066e7 100644
> --- a/gdb/d-valprint.c
> +++ b/gdb/d-valprint.c
> @@ -29,7 +29,7 @@
>  
>  static int
>  dynamic_array_type (struct type *type, const gdb_byte *valaddr,
> -		    int embedded_offset, CORE_ADDR address,
> +		    LONGEST embedded_offset, CORE_ADDR address,
>  		    struct ui_file *stream, int recurse,
>  		    const struct value *val,
>  		    const struct value_print_options *options)
> @@ -71,9 +71,9 @@ dynamic_array_type (struct type *type, const gdb_byte *valaddr,
>  
>  /* Implements the la_val_print routine for language D.  */
>  void
> -d_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
> -             CORE_ADDR address, struct ui_file *stream, int recurse,
> -	     const struct value *val,
> +d_val_print (struct type *type, const gdb_byte *valaddr,
> +	     LONGEST embedded_offset, CORE_ADDR address,
> +	     struct ui_file *stream, int recurse, const struct value *val,
>               const struct value_print_options *options)
>  {
>    int ret;
> diff --git a/gdb/doc/observer.texi b/gdb/doc/observer.texi
> index 24233cb..d05ebbe 100644
> --- a/gdb/doc/observer.texi
> +++ b/gdb/doc/observer.texi
> @@ -216,7 +216,7 @@ The inferior @var{inf} has been removed from the list of inferiors.
>  This method is called immediately before freeing @var{inf}.
>  @end deftypefun
>  
> -@deftypefun void memory_changed (CORE_ADDR @var{addr}, int @var{len}, const bfd_byte *@var{data})
> +@deftypefun void memory_changed (CORE_ADDR @var{addr}, LONGEST @var{len}, const bfd_byte *@var{data})
>  Bytes from @var{data} to @var{data} + @var{len} have been written
>  to the current inferior at @var{addr}.
>  @end deftypefun
> diff --git a/gdb/doublest.c b/gdb/doublest.c
> index c8c9e05..71c27c5 100644
> --- a/gdb/doublest.c
> +++ b/gdb/doublest.c
> @@ -770,7 +770,7 @@ floatformat_from_doublest (const struct floatformat *fmt,
>     but not passed on by GDB.  This should be fixed.  */
>  
>  static const struct floatformat *
> -floatformat_from_length (struct gdbarch *gdbarch, int len)
> +floatformat_from_length (struct gdbarch *gdbarch, ULONGEST len)
X
>  {
>    const struct floatformat *format;
>  
> @@ -798,8 +798,8 @@ floatformat_from_length (struct gdbarch *gdbarch, int len)
>    else
>      format = NULL;
>    if (format == NULL)
> -    error (_("Unrecognized %d-bit floating-point type."),
> -	   len * TARGET_CHAR_BIT);
> +    error (_("Unrecognized %s-bit floating-point type."),
> +	   pulongest (len * TARGET_CHAR_BIT));

And plongest then.


>    return format;
>  }
>  
> diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
> index caef546..e83e4d5 100644
> --- a/gdb/dwarf2loc.c
> +++ b/gdb/dwarf2loc.c
> @@ -1334,19 +1334,19 @@ insert_bits (unsigned int datum,
>     BITS_BIG_ENDIAN is taken directly from gdbarch.  */
>  
>  static void
> -copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
> -	      const gdb_byte *source, unsigned int source_offset_bits,
> -	      unsigned int bit_count,
> +copy_bitwise (gdb_byte *dest, ULONGEST dest_offset_bits,
> +	      const gdb_byte *source, ULONGEST source_offset,
> +	      ULONGEST bit_count,
>  	      int bits_big_endian)
>  {
> -  unsigned int dest_avail;
> +  unsigned int dest_avail, source_offset_bits;
>    int datum;
>  
>    /* Reduce everything to byte-size pieces.  */
>    dest += dest_offset_bits / 8;
>    dest_offset_bits %= 8;
> -  source += source_offset_bits / 8;
> -  source_offset_bits %= 8;
> +  source += source_offset / 8;
> +  source_offset_bits = source_offset % 8;

I do not fully understand this whole change but it looks unrelated to this
patch to me.


>  
>    dest_avail = 8 - dest_offset_bits % 8;
>  
> @@ -1384,13 +1384,13 @@ static void
>  read_pieced_value (struct value *v)
>  {
>    int i;
> -  long offset = 0;
> +  LONGEST offset = 0;
>    ULONGEST bits_to_skip;
>    gdb_byte *contents;
>    struct piece_closure *c
>      = (struct piece_closure *) value_computed_closure (v);
>    struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
> -  size_t type_len;
> +  ULONGEST type_len;
>    size_t buffer_size = 0;
>    char *buffer = NULL;
>    struct cleanup *cleanup;
> @@ -1417,8 +1417,8 @@ read_pieced_value (struct value *v)
>    for (i = 0; i < c->n_pieces && offset < type_len; i++)
>      {
>        struct dwarf_expr_piece *p = &c->pieces[i];
> -      size_t this_size, this_size_bits;
> -      long dest_offset_bits, source_offset_bits, source_offset;
> +      ULONGEST this_size, this_size_bits;
> +      LONGEST dest_offset_bits, source_offset_bits, source_offset;
>        const gdb_byte *intermediate_buffer;
>  
>        /* Compute size, source, and destination offsets for copying, in
> @@ -1573,7 +1573,7 @@ write_pieced_value (struct value *to, struct value *from)
>    struct piece_closure *c
>      = (struct piece_closure *) value_computed_closure (to);
>    struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
> -  size_t type_len;
> +  ULONGEST type_len;
>    size_t buffer_size = 0;
>    char *buffer = NULL;
>    struct cleanup *cleanup;
> @@ -1589,7 +1589,7 @@ write_pieced_value (struct value *to, struct value *from)
>    cleanup = make_cleanup (free_current_contents, &buffer);
>  
>    contents = value_contents (from);
> -  bits_to_skip = 8 * value_offset (to);
> +  bits_to_skip = (ULONGEST)(8 * value_offset (to));

Excessive/needless cast.


>    if (value_bitsize (to))
>      {
>        bits_to_skip += value_bitpos (to);
> @@ -1601,8 +1601,8 @@ write_pieced_value (struct value *to, struct value *from)
>    for (i = 0; i < c->n_pieces && offset < type_len; i++)
>      {
>        struct dwarf_expr_piece *p = &c->pieces[i];
> -      size_t this_size_bits, this_size;
> -      long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
> +      ULONGEST this_size_bits, this_size;
> +      LONGEST dest_offset_bits, source_offset_bits, dest_offset, source_offset;
>        int need_bitwise;
>        const gdb_byte *source_buffer;
>  
> @@ -1731,8 +1731,8 @@ write_pieced_value (struct value *to, struct value *from)
>     implicit pointer.  */
>  
>  static int
> -check_pieced_value_bits (const struct value *value, int bit_offset,
> -			 int bit_length,
> +check_pieced_value_bits (const struct value *value, LONGEST bit_offset,
> +			 ULONGEST bit_length,
X
>  			 enum dwarf_value_location check_for)
>  {
>    struct piece_closure *c
> @@ -1786,8 +1786,8 @@ check_pieced_value_bits (const struct value *value, int bit_offset,
>  }
>  
>  static int
> -check_pieced_value_validity (const struct value *value, int bit_offset,
> -			     int bit_length)
> +check_pieced_value_validity (const struct value *value, LONGEST bit_offset,
> +			     ULONGEST bit_length)
X
>  {
>    return check_pieced_value_bits (value, bit_offset, bit_length,
>  				  DWARF_VALUE_MEMORY);
> @@ -1805,8 +1805,8 @@ check_pieced_value_invalid (const struct value *value)
>     a synthetic pointer.  */
>  
>  static int
> -check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
> -				int bit_length)
> +check_pieced_synthetic_pointer (const struct value *value, LONGEST bit_offset,
> +				ULONGEST bit_length)
X
>  {
>    return check_pieced_value_bits (value, bit_offset, bit_length,
>  				  DWARF_VALUE_IMPLICIT_POINTER);
> @@ -1831,9 +1831,10 @@ indirect_pieced_value (struct value *value)
>    struct type *type;
>    struct frame_info *frame;
>    struct dwarf2_locexpr_baton baton;
> -  int i, bit_offset, bit_length;
> +  int i;
> +  ULONGEST bit_length;
X
>    struct dwarf_expr_piece *piece = NULL;
> -  LONGEST byte_offset;
> +  LONGEST byte_offset, bit_offset;
>  
>    type = check_typedef (value_type (value));
>    if (TYPE_CODE (type) != TYPE_CODE_PTR)
> @@ -2080,7 +2081,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
>  	    struct value *value = dwarf_expr_fetch (ctx, 0);
>  	    gdb_byte *contents;
>  	    const gdb_byte *val_bytes;
> -	    size_t n = TYPE_LENGTH (value_type (value));
> +	    ULONGEST n = TYPE_LENGTH (value_type (value));
>  
>  	    if (byte_offset + TYPE_LENGTH (type) > n)
>  	      invalid_synthetic_pointer ();
> diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
> index 412fe5b..c71e366 100644
> --- a/gdb/dwarf2read.c
> +++ b/gdb/dwarf2read.c
> @@ -804,7 +804,7 @@ struct die_info
>  /* Blocks are a bunch of untyped bytes.  */
>  struct dwarf_block
>    {
> -    unsigned int size;
> +    ULONGEST size;

This is size of dwarf_block->data so it should be size_t.  Anything larger
does not make sense.  One may need to do some explicit code for size checks if
split warns on it.


>  
>      /* Valid only if SIZE is not zero.  */
>      gdb_byte *data;
> @@ -940,12 +940,12 @@ dwarf2_complex_location_expr_complaint (void)
>  }
>  
>  static void
> -dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
> -					      int arg3)
> +dwarf2_const_value_length_mismatch_complaint (const char *arg1, ULONGEST arg2,
X
> +					      ULONGEST arg3)
X
>  {
>    complaint (&symfile_complaints,
> -	     _("const value length mismatch for '%s', got %d, expected %d"),
> -	     arg1, arg2, arg3);
> +	     _("const value length mismatch for '%s', got %s, expected %s"),
> +	     arg1, pulongest (arg2), pulongest (arg3));

There will be plongest 2x then.


>  }
>  
>  static void
> @@ -8202,7 +8202,7 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die,
>  	         object, and then subtract off the number of bits of
>  	         the field itself.  The result is the bit offset of
>  	         the LSB of the field.  */
> -	      int anonymous_size;
> +	      ULONGEST anonymous_size;
X
>  	      int bit_offset = DW_UNSND (attr);
>  
>  	      attr = dwarf2_attr (die, DW_AT_byte_size, cu);
> @@ -15314,12 +15314,12 @@ dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
>  	case DW_FORM_block4:
>  	case DW_FORM_block:
>  	case DW_FORM_block1:
> -	  fprintf_unfiltered (f, "block: size %d",
> -			      DW_BLOCK (&die->attrs[i])->size);
> +	  fprintf_unfiltered (f, "block: size %s",
> +			      pulongest (DW_BLOCK (&die->attrs[i])->size));

This would be %z for size_t afterwards.


>  	  break;
>  	case DW_FORM_exprloc:
> -	  fprintf_unfiltered (f, "expression: size %u",
> -			      DW_BLOCK (&die->attrs[i])->size);
> +	  fprintf_unfiltered (f, "expression: size %s",
> +			      pulongest (DW_BLOCK (&die->attrs[i])->size));

This would be %z for size_t afterwards.


>  	  break;
>  	case DW_FORM_ref_addr:
>  	  fprintf_unfiltered (f, "ref address: ");
> diff --git a/gdb/eval.c b/gdb/eval.c
> index de1c4bd..91028cd 100644
> --- a/gdb/eval.c
> +++ b/gdb/eval.c
> @@ -319,7 +319,8 @@ evaluate_struct_tuple (struct value *struct_val,
>        int pc = *pos;
>        struct value *val = NULL;
>        int nlabels = 0;
> -      int bitpos, bitsize;
> +      int bitsize;
> +      LONGEST bitpos;
>        bfd_byte *addr;
>  
>        /* Skip past the labels, and count them.  */
> @@ -462,7 +463,7 @@ init_array_element (struct value *array, struct value *element,
>  		    enum noside noside, LONGEST low_bound, LONGEST high_bound)
>  {
>    LONGEST index;
> -  int element_size = TYPE_LENGTH (value_type (element));
> +  ULONGEST element_size = TYPE_LENGTH (value_type (element));
X
>  
>    if (exp->elts[*pos].opcode == BINOP_COMMA)
>      {
> @@ -625,11 +626,11 @@ binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
>      /* FIXME: Also mixed integral/booleans, with result an integer.  */
>      {
>        const struct builtin_type *builtin = builtin_type (gdbarch);
> -      unsigned int promoted_len1 = TYPE_LENGTH (type1);
> -      unsigned int promoted_len2 = TYPE_LENGTH (type2);
> +      ULONGEST promoted_len1 = TYPE_LENGTH (type1);
> +      ULONGEST promoted_len2 = TYPE_LENGTH (type2);
>        int is_unsigned1 = TYPE_UNSIGNED (type1);
>        int is_unsigned2 = TYPE_UNSIGNED (type2);
> -      unsigned int result_len;
> +      ULONGEST result_len;
>        int unsigned_operation;
>  
>        /* Determine type length and signedness after promotion for
> @@ -796,7 +797,7 @@ evaluate_subexp_standard (struct type *expect_type,
>    int upper, lower;
>    int code;
>    int ix;
> -  long mem_offset;
> +  LONGEST mem_offset;
>    struct type **arg_types;
>    int save_pos1;
>    struct symbol *function = NULL;
> @@ -985,7 +986,7 @@ evaluate_subexp_standard (struct type *expect_type,
>  	  struct type *range_type = TYPE_INDEX_TYPE (type);
>  	  struct type *element_type = TYPE_TARGET_TYPE (type);
>  	  struct value *array = allocate_value (expect_type);
> -	  int element_size = TYPE_LENGTH (check_typedef (element_type));
> +	  ULONGEST element_size = TYPE_LENGTH (check_typedef (element_type));
X
>  	  LONGEST low_bound, high_bound, index;
>  
>  	  if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
> @@ -1994,7 +1995,8 @@ evaluate_subexp_standard (struct type *expect_type,
>        {
>          struct type *type = value_type (arg1);
>          struct type *real_type;
> -        int full, top, using_enc;
> +        int full, using_enc;
> +	LONGEST top;
>  	struct value_print_options opts;
>  
>  	get_user_print_options (&opts);
> diff --git a/gdb/f-lang.c b/gdb/f-lang.c
> index 3368d01..e3bd983 100644
> --- a/gdb/f-lang.c
> +++ b/gdb/f-lang.c
> @@ -138,7 +138,7 @@ f_printchar (int c, struct type *type, struct ui_file *stream)
>  
>  static void
>  f_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
> -	    unsigned int length, const char *encoding, int force_ellipses,
> +	    ULONGEST length, const char *encoding, int force_ellipses,
>  	    const struct value_print_options *options)
>  {
>    const char *type_encoding = f_get_encoding (type);
> diff --git a/gdb/f-lang.h b/gdb/f-lang.h
> index 4aae3c5..d20a46f 100644
> --- a/gdb/f-lang.h
> +++ b/gdb/f-lang.h
> @@ -28,7 +28,7 @@ extern void f_error (char *);	/* Defined in f-exp.y */
>  extern void f_print_type (struct type *, const char *, struct ui_file *, int,
>  			  int);
>  
> -extern void f_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
> +extern void f_val_print (struct type *, const gdb_byte *, LONGEST, CORE_ADDR,
>  			 struct ui_file *, int,
>  			 const struct value *,
>  			 const struct value_print_options *);
> diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
> index 62a7136..f95a771 100644
> --- a/gdb/f-valprint.c
> +++ b/gdb/f-valprint.c
> @@ -46,7 +46,7 @@ static void f77_create_arrayprint_offset_tbl (struct type *,
>  					      struct ui_file *);
>  static void f77_get_dynamic_length_of_aggregate (struct type *);
>  
> -int f77_array_offset_tbl[MAX_FORTRAN_DIMS + 1][2];
> +LONGEST f77_array_offset_tbl[MAX_FORTRAN_DIMS + 1][2];
>  
>  /* Array which holds offsets to be applied to get a row's elements
>     for a given array.  Array also holds the size of each subarray.  */
> @@ -124,7 +124,7 @@ static void
>  f77_create_arrayprint_offset_tbl (struct type *type, struct ui_file *stream)
>  {
>    struct type *tmp_type;
> -  int eltlen;
> +  ULONGEST eltlen;
X
>    int ndimen = 1;
>    int upper, lower;
>  
> @@ -164,7 +164,7 @@ f77_create_arrayprint_offset_tbl (struct type *type, struct ui_file *stream)
>  static void
>  f77_print_array_1 (int nss, int ndimensions, struct type *type,
>  		   const gdb_byte *valaddr,
> -		   int embedded_offset, CORE_ADDR address,
> +		   LONGEST embedded_offset, CORE_ADDR address,
>  		   struct ui_file *stream, int recurse,
>  		   const struct value *val,
>  		   const struct value_print_options *options,
> @@ -215,7 +215,7 @@ f77_print_array_1 (int nss, int ndimensions, struct type *type,
>  
>  static void
>  f77_print_array (struct type *type, const gdb_byte *valaddr,
> -		 int embedded_offset,
> +		 LONGEST embedded_offset,
>  		 CORE_ADDR address, struct ui_file *stream,
>  		 int recurse,
>  		 const struct value *val,
> @@ -258,8 +258,9 @@ static const struct generic_val_print_decorations f_decorations =
>     function; they are identical.  */
>  
>  void
> -f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
> -	     CORE_ADDR address, struct ui_file *stream, int recurse,
> +f_val_print (struct type *type, const gdb_byte *valaddr,
> +	     LONGEST embedded_offset, CORE_ADDR address,
> +	     struct ui_file *stream, int recurse,
>  	     const struct value *original_value,
>  	     const struct value_print_options *options)
>  {
> @@ -371,7 +372,7 @@ f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
>        fprintf_filtered (stream, "( ");
>        for (index = 0; index < TYPE_NFIELDS (type); index++)
>          {
> -          int offset = TYPE_FIELD_BITPOS (type, index) / 8;
> +	  LONGEST offset = TYPE_FIELD_BITPOS (type, index) / 8;
>  
>            val_print (TYPE_FIELD_TYPE (type, index), valaddr,
>  		     embedded_offset + offset,
> diff --git a/gdb/findcmd.c b/gdb/findcmd.c
> index 3fce269..6343a34 100644
> --- a/gdb/findcmd.c
> +++ b/gdb/findcmd.c
> @@ -169,7 +169,7 @@ parse_find_args (char *args, ULONGEST *max_countp,
>    while (*s != '\0')
>      {
>        LONGEST x;
> -      int val_bytes;
> +      ULONGEST val_bytes;
X
>  
>        while (isspace (*s))
>  	++s;
> diff --git a/gdb/findvar.c b/gdb/findvar.c
> index 9009e6f..d1d8266 100644
> --- a/gdb/findvar.c
> +++ b/gdb/findvar.c
> @@ -92,7 +92,7 @@ extract_unsigned_integer (const gdb_byte *addr, int len,
>    const unsigned char *startaddr = addr;
>    const unsigned char *endaddr = startaddr + len;
>  
> -  if (len > (int) sizeof (ULONGEST))
> +  if (len > sizeof (ULONGEST))
>      error (_("\
>  That operation is not available on integers of more than %d bytes."),
>  	   (int) sizeof (ULONGEST));
> @@ -415,7 +415,7 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
>    struct value *v;
>    struct type *type = SYMBOL_TYPE (var);
>    CORE_ADDR addr;
> -  int len;
> +  ULONGEST len;
X
>  
>    /* Call check_typedef on our type to make sure that, if TYPE is
>       a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
> @@ -613,7 +613,7 @@ default_value_from_register (struct type *type, int regnum,
>  			     struct frame_info *frame)
>  {
>    struct gdbarch *gdbarch = get_frame_arch (frame);
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>    struct value *value = allocate_value (type);
>  
>    VALUE_LVAL (value) = lval_register;
> @@ -643,10 +643,10 @@ void
>  read_frame_register_value (struct value *value, struct frame_info *frame)
>  {
>    struct gdbarch *gdbarch = get_frame_arch (frame);
> -  int offset = 0;
> -  int reg_offset = value_offset (value);
> +  LONGEST offset = 0;
> +  LONGEST reg_offset = value_offset (value);
>    int regnum = VALUE_REGNUM (value);
> -  int len = TYPE_LENGTH (check_typedef (value_type (value)));
> +  ULONGEST len = TYPE_LENGTH (check_typedef (value_type (value)));
X
>  
>    gdb_assert (VALUE_LVAL (value) == lval_register);
>  
> @@ -661,7 +661,7 @@ read_frame_register_value (struct value *value, struct frame_info *frame)
>    while (len > 0)
>      {
>        struct value *regval = get_frame_register_value (frame, regnum);
> -      int reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset;
> +      ULONGEST reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset;
X
>  
>        /* If the register length is larger than the number of bytes
>           remaining to copy, then only copy the appropriate bytes.  */
> diff --git a/gdb/frv-tdep.c b/gdb/frv-tdep.c
> index 1f2400a..e5a589d 100644
> --- a/gdb/frv-tdep.c
> +++ b/gdb/frv-tdep.c
> @@ -1123,7 +1123,7 @@ frv_extract_return_value (struct type *type, struct regcache *regcache,
>  {
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    if (len <= 4)
>      {
> @@ -1142,7 +1142,7 @@ frv_extract_return_value (struct type *type, struct regcache *regcache,
>      }
>    else
>      internal_error (__FILE__, __LINE__,
> -		    _("Illegal return value length: %d"), len);
> +		    _("Illegal return value length: %s"), pulongest (len));

It will be plongest then.


>  }
>  
>  static CORE_ADDR
> @@ -1213,7 +1213,7 @@ frv_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    char valbuf[4];
>    struct value *arg;
>    struct type *arg_type;
> -  int len;
> +  ULONGEST len;
X
>    enum type_code typecode;
>    CORE_ADDR regval;
>    int stack_space;
> @@ -1331,7 +1331,7 @@ static void
>  frv_store_return_value (struct type *type, struct regcache *regcache,
>                          const gdb_byte *valbuf)
>  {
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    if (len <= 4)
>      {
> @@ -1347,7 +1347,8 @@ frv_store_return_value (struct type *type, struct regcache *regcache,
>      }
>    else
>      internal_error (__FILE__, __LINE__,
> -                    _("Don't know how to return a %d-byte value."), len);
> +                    _("Don't know how to return a %s-byte value."),
> +		    pulongest (len));

It will be plongest then.

>  }
>  
>  static enum return_value_convention
> diff --git a/gdb/gdbcore.h b/gdb/gdbcore.h
> index 776ce9f..9408fc1 100644
> --- a/gdb/gdbcore.h
> +++ b/gdb/gdbcore.h
> @@ -45,11 +45,11 @@ extern void memory_error (int status, CORE_ADDR memaddr);
>  
>  /* Like target_read_memory, but report an error if can't read.  */
>  
> -extern void read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
> +extern void read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len);

As it operates with in-memory MYADDR buffer it should be rather size_t.
split will give some warnings but those should be just one-time verified the
passing is correct - therefore the signedness would not need to be kept.

We could also make it LONGEST first and make it size_t in a second patch.

>  
>  /* Like target_read_stack, but report an error if can't read.  */
>  
> -extern void read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
> +extern void read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len);

Likewise.

>  
>  /* Read an integer from debugged memory, given address and number of
>     bytes.  */
> @@ -83,7 +83,8 @@ CORE_ADDR read_memory_typed_address (CORE_ADDR addr, struct type *type);
>     byteswapping, alignment, different sizes for host vs. target types,
>     etc.  */
>  
> -extern void write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len);
> +extern void write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
> +			  ULONGEST len);

Likewise.

>  
>  /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer.  */
>  extern void write_memory_unsigned_integer (CORE_ADDR addr, int len,
> diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
> index 60b0839..b56d7f1 100644
> --- a/gdb/gdbtypes.c
> +++ b/gdb/gdbtypes.c
> @@ -1905,7 +1905,7 @@ allocate_gnat_aux_type (struct type *type)
>     where init_type is called with a NULL value for NAME).  */
>  
>  struct type *
> -init_type (enum type_code code, int length, int flags,
> +init_type (enum type_code code, ULONGEST length, int flags,
X
>  	   char *name, struct objfile *objfile)
>  {
>    struct type *type;
> @@ -2137,8 +2137,8 @@ is_public_ancestor (struct type *base, struct type *dclass)
>  
>  static int
>  is_unique_ancestor_worker (struct type *base, struct type *dclass,
> -			   int *offset,
> -			   const gdb_byte *valaddr, int embedded_offset,
> +			   LONGEST *offset,
> +			   const gdb_byte *valaddr, LONGEST embedded_offset,
>  			   CORE_ADDR address, struct value *val)
>  {
>    int i, count = 0;
> @@ -2149,7 +2149,7 @@ is_unique_ancestor_worker (struct type *base, struct type *dclass,
>    for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
>      {
>        struct type *iter;
> -      int this_offset;
> +      LONGEST this_offset;
>  
>        iter = check_typedef (TYPE_BASECLASS (dclass, i));
>  
> @@ -2190,7 +2190,7 @@ is_unique_ancestor_worker (struct type *base, struct type *dclass,
>  int
>  is_unique_ancestor (struct type *base, struct value *val)
>  {
> -  int offset = -1;
> +  LONGEST offset = -1;
>  
>    return is_unique_ancestor_worker (base, value_type (val), &offset,
>  				    value_contents_for_printing (val),
> @@ -3083,7 +3083,7 @@ recursive_dump_type (struct type *type, int spaces)
>        break;
>      }
>    puts_filtered ("\n");
> -  printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
> +  printfi_filtered (spaces, "length %s\n", pulongest (TYPE_LENGTH (type)));
>    if (TYPE_OBJFILE_OWNED (type))
>      {
>        printfi_filtered (spaces, "objfile ");
> @@ -3203,8 +3203,8 @@ recursive_dump_type (struct type *type, int spaces)
>  			  idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
>        else
>  	printfi_filtered (spaces + 2,
> -			  "[%d] bitpos %d bitsize %d type ",
> -			  idx, TYPE_FIELD_BITPOS (type, idx),
> +			  "[%d] bitpos %s bitsize %d type ",
> +			  idx, plongest (TYPE_FIELD_BITPOS (type, idx)),
>  			  TYPE_FIELD_BITSIZE (type, idx));
>        gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
>        printf_filtered (" name '%s' (",
> @@ -3486,7 +3486,7 @@ copy_type (const struct type *type)
>     CODE, LENGTH, and NAME fields.  */
>  struct type *
>  arch_type (struct gdbarch *gdbarch,
> -	   enum type_code code, int length, char *name)
> +	   enum type_code code, ULONGEST length, char *name)
X
>  {
>    struct type *type;
>  
> diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
> index 887dfdb..8c4c0de 100644
> --- a/gdb/gdbtypes.h
> +++ b/gdb/gdbtypes.h
> @@ -514,7 +514,7 @@ struct main_type
>  	   gdbarch_bits_big_endian=0 targets, it is the bit offset to
>  	   the LSB.  */
>  
> -	int bitpos;
> +	LONGEST bitpos;
>  
>  	/* Enum value.  */
>  	LONGEST enumval;
> @@ -684,7 +684,7 @@ struct type
>       HOST_CHAR_BIT.  However, this would still fail to address
>       machines based on a ternary or decimal representation.  */
>    
> -  unsigned length;
> +  ULONGEST length;
>  
>    /* Core type, shared by a group of qualified types.  */
>    struct main_type *main_type;
> @@ -1398,11 +1398,12 @@ extern struct type *alloc_type_copy (const struct type *);
>  extern struct gdbarch *get_type_arch (const struct type *);
>  
>  /* Helper function to construct objfile-owned types.  */
> -extern struct type *init_type (enum type_code, int, int, char *,
> +extern struct type *init_type (enum type_code, ULONGEST, int, char *,
X
>  			       struct objfile *);
>  
>  /* Helper functions to construct architecture-owned types.  */
> -extern struct type *arch_type (struct gdbarch *, enum type_code, int, char *);
> +extern struct type *arch_type (struct gdbarch *, enum type_code, ULONGEST,
X
> +			       char *);
>  extern struct type *arch_integer_type (struct gdbarch *, int, int, char *);
>  extern struct type *arch_character_type (struct gdbarch *, int, int, char *);
>  extern struct type *arch_boolean_type (struct gdbarch *, int, int, char *);
> diff --git a/gdb/gnu-v2-abi.c b/gdb/gnu-v2-abi.c
> index e635e8f..d6b7d27 100644
> --- a/gdb/gnu-v2-abi.c
> +++ b/gdb/gnu-v2-abi.c
> @@ -85,8 +85,8 @@ gnuv2_is_operator_name (const char *name)
>  
>     TYPE is the type in which F is located.  */
>  static struct value *
> -gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
> +gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field *f, int j,

Sorry this is unrelated formatting change.


> -			struct type * type, int offset)
> +			struct type *type, LONGEST offset)
>  {
>    struct value *arg1 = *arg1p;
>    struct type *type1 = check_typedef (value_type (arg1));
> @@ -187,7 +187,8 @@ gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
>  
>  
>  static struct type *
> -gnuv2_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
> +gnuv2_value_rtti_type (struct value *v, int *full, LONGEST *top,
> +		       int *using_enc)
>  {
>    struct type *known_type;
>    struct type *rtti_type;
> @@ -342,9 +343,9 @@ vb_match (struct type *type, int index, struct type *basetype)
>     target).  The result is the offset of the baseclass value relative
>     to (the address of)(ARG) + OFFSET.  */
>  
> -static int
> +static LONGEST
>  gnuv2_baseclass_offset (struct type *type, int index,
> -			const bfd_byte *valaddr, int embedded_offset,
> +			const bfd_byte *valaddr, LONGEST embedded_offset,
>  			CORE_ADDR address, const struct value *val)
>  {
>    struct type *basetype = TYPE_BASECLASS (type, index);
> @@ -362,8 +363,8 @@ gnuv2_baseclass_offset (struct type *type, int index,
>  	  if (vb_match (type, i, basetype))
>  	    {
>  	      struct type *field_type;
> -	      int field_offset;
> -	      int field_length;
> +	      LONGEST field_offset;
> +	      ULONGEST field_length;
X
>  	      CORE_ADDR addr;
>  
>  	      field_type = check_typedef (TYPE_FIELD_TYPE (type, i));
> @@ -387,7 +388,7 @@ gnuv2_baseclass_offset (struct type *type, int index,
>  	  /* Don't go through baseclass_offset, as that wraps
>  	     exceptions, thus, inner exceptions would be wrapped more
>  	     than once.  */
> -	  int boffset =
> +	  LONGEST boffset =
>  	    gnuv2_baseclass_offset (type, i, valaddr,
>  				    embedded_offset, address, val);
>  
> diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
> index ed94b84..180d96f 100644
> --- a/gdb/gnu-v3-abi.c
> +++ b/gdb/gnu-v3-abi.c
> @@ -105,7 +105,7 @@ build_gdb_vtable_type (struct gdbarch *arch)
>  {
>    struct type *t;
>    struct field *field_list, *field;
> -  int offset;
> +  ULONGEST offset;
X
>  
>    struct type *void_ptr_type
>      = builtin_type (arch)->builtin_data_ptr;
> @@ -181,7 +181,7 @@ vtable_ptrdiff_type (struct gdbarch *gdbarch)
>  /* Return the offset from the start of the imaginary `struct
>     gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
>     (i.e., where objects' virtual table pointers point).  */
> -static int
> +static LONGEST
>  vtable_address_point_offset (struct gdbarch *gdbarch)
>  {
>    struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
> @@ -272,7 +272,7 @@ gnuv3_get_vtable (struct gdbarch *gdbarch,
>  
>  static struct type *
>  gnuv3_rtti_type (struct value *value,
> -                 int *full_p, int *top_p, int *using_enc_p)
> +                 int *full_p, LONGEST *top_p, int *using_enc_p)
>  {
>    struct gdbarch *gdbarch;
>    struct type *values_type = check_typedef (value_type (value));
> @@ -384,7 +384,7 @@ gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
>  static struct value *
>  gnuv3_virtual_fn_field (struct value **value_p,
>                          struct fn_field *f, int j,
> -			struct type *vfn_base, int offset)
> +			struct type *vfn_base, LONGEST offset)
>  {
>    struct type *values_type = check_typedef (value_type (*value_p));
>    struct gdbarch *gdbarch;
> @@ -414,16 +414,16 @@ gnuv3_virtual_fn_field (struct value **value_p,
>  
>     -1 is returned on error.  */
>  
> -static int
> +static LONGEST
>  gnuv3_baseclass_offset (struct type *type, int index,
> -			const bfd_byte *valaddr, int embedded_offset,
> +			const bfd_byte *valaddr, LONGEST embedded_offset,
>  			CORE_ADDR address, const struct value *val)
>  {
>    struct gdbarch *gdbarch;
>    struct type *ptr_type;
>    struct value *vtable;
>    struct value *vbase_array;
> -  long int cur_base_offset, base_offset;
> +  LONGEST cur_base_offset, base_offset;
>  
>    /* Determine architecture.  */
>    gdbarch = get_type_arch (type);
> @@ -446,7 +446,7 @@ gnuv3_baseclass_offset (struct type *type, int index,
>    cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch);
>    if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0)
>      error (_("Misaligned vbase offset."));
> -  cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type));
> +  cur_base_offset = cur_base_offset / ((LONGEST) TYPE_LENGTH (ptr_type));
>  
>    vtable = gnuv3_get_vtable (gdbarch, type, address + embedded_offset);
>    gdb_assert (vtable != NULL);
> @@ -490,7 +490,7 @@ gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset,
>       we're out of luck.  */
>    for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
>      {
> -      int pos;
> +      LONGEST pos;
>        struct type *basetype;
>  
>        if (BASETYPE_VIA_VIRTUAL (domain, i))
> diff --git a/gdb/go-lang.h b/gdb/go-lang.h
> index 67b5d93..51a1f7a 100644
> --- a/gdb/go-lang.h
> +++ b/gdb/go-lang.h
> @@ -80,7 +80,7 @@ extern void go_print_type (struct type *type, const char *varstring,
>  /* Defined in go-valprint.c.  */
>  
>  extern void go_val_print (struct type *type, const gdb_byte *valaddr,
> -			  int embedded_offset, CORE_ADDR address,
> +			  LONGEST embedded_offset, CORE_ADDR address,
>  			  struct ui_file *stream, int recurse,
>  			  const struct value *val,
>  			  const struct value_print_options *options);
> diff --git a/gdb/go-valprint.c b/gdb/go-valprint.c
> index 3be4927..3a465eb 100644
> --- a/gdb/go-valprint.c
> +++ b/gdb/go-valprint.c
> @@ -83,7 +83,7 @@ print_go_string (struct type *type, const gdb_byte *valaddr,
>  /* Implements the la_val_print routine for language Go.  */
>  
>  void
> -go_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
> +go_val_print (struct type *type, const gdb_byte *valaddr, LONGEST embedded_offset,
>  	      CORE_ADDR address, struct ui_file *stream, int recurse,
>  	      const struct value *val,
>  	      const struct value_print_options *options)
> diff --git a/gdb/h8300-tdep.c b/gdb/h8300-tdep.c
> index aa056f9..c3c8a7e 100644
> --- a/gdb/h8300-tdep.c
> +++ b/gdb/h8300-tdep.c
> @@ -642,7 +642,7 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>  		       int struct_return, CORE_ADDR struct_addr)
>  {
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
> -  int stack_alloc = 0, stack_offset = 0;
> +  ULONGEST stack_alloc = 0, stack_offset = 0;
>    int wordsize = BINWORD (gdbarch);
>    int reg = E_ARG0_REGNUM;
>    int argument;
> @@ -668,11 +668,11 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    for (argument = 0; argument < nargs; argument++)
>      {
>        struct type *type = value_type (args[argument]);
> -      int len = TYPE_LENGTH (type);
> +      ULONGEST len = TYPE_LENGTH (type);
X
>        char *contents = (char *) value_contents (args[argument]);
>  
>        /* Pad the argument appropriately.  */
> -      int padded_len = align_up (len, wordsize);
> +      ULONGEST padded_len = align_up (len, wordsize);
X
>        gdb_byte *padded = alloca (padded_len);
>  
>        memset (padded, 0, padded_len);
> @@ -700,7 +700,7 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>  	      /* 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;
> +	      ULONGEST offset;
X
>  
>  	      for (offset = 0; offset < padded_len; offset += wordsize)
>  		{
> diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
> index 7f7fb8e..585da78 100644
> --- a/gdb/hppa-tdep.c
> +++ b/gdb/hppa-tdep.c
> @@ -963,7 +963,7 @@ hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>      {
>        struct value *arg = args[i];
>        struct type *type = value_type (arg);
> -      int len = TYPE_LENGTH (type);
> +      ULONGEST len = TYPE_LENGTH (type);
X
>        const bfd_byte *valbuf;
>        bfd_byte fptrbuf[8];
>        int regnum;
> @@ -1158,7 +1158,7 @@ hppa64_return_value (struct gdbarch *gdbarch, struct type *func_type,
>  		     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)
> diff --git a/gdb/i386-darwin-tdep.c b/gdb/i386-darwin-tdep.c
> index c353154..40a772b 100644
> --- a/gdb/i386-darwin-tdep.c
> +++ b/gdb/i386-darwin-tdep.c
> @@ -119,7 +119,7 @@ i386_m128_p (struct type *type)
>  
>  /* Return the alignment for TYPE when passed as an argument.  */
>  
> -static int
> +static ULONGEST
X
>  i386_darwin_arg_type_alignment (struct type *type)
>  {
>    type = check_typedef (type);
> @@ -139,7 +139,7 @@ i386_darwin_arg_type_alignment (struct type *type)
>        || TYPE_CODE (type) == TYPE_CODE_UNION)
>      {
>        int i;
> -      int res = 4;
> +      ULONGEST res = 4;
X
>        for (i = 0; i < TYPE_NFIELDS (type); i++)
>          res = max (res,
>                     i386_darwin_arg_type_alignment (TYPE_FIELD_TYPE (type, i)));
> @@ -166,7 +166,7 @@ i386_darwin_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>  
>    for (write_pass = 0; write_pass < 2; write_pass++)
>      {
> -      int args_space = 0;
> +      ULONGEST args_space = 0;
X
>        int num_m128 = 0;
>  
>        if (struct_return)
> @@ -196,8 +196,8 @@ i386_darwin_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>              }
>            else
>              {
> -              int len = TYPE_LENGTH (arg_type);
> -              int align = i386_darwin_arg_type_alignment (arg_type);
> +              ULONGEST len = TYPE_LENGTH (arg_type);
X
> +              ULONGEST align = i386_darwin_arg_type_alignment (arg_type);
X
>  
>                args_space = align_up (args_space, align);
>                if (write_pass)
> diff --git a/gdb/i386-nat.c b/gdb/i386-nat.c
> index 753de67..0ba1ed2 100644
> --- a/gdb/i386-nat.c
> +++ b/gdb/i386-nat.c
> @@ -293,7 +293,7 @@ static int i386_remove_aligned_watchpoint (struct i386_debug_reg_state *state,
>     valid value, bombs through internal_error.  */
>  static int i386_handle_nonaligned_watchpoint (struct i386_debug_reg_state *state,
>  					      i386_wp_op_t what,
> -					      CORE_ADDR addr, int len,
> +					      CORE_ADDR addr, ULONGEST len,
X
>  					      enum target_hw_bp_type type);
>  
>  /* Implementation.  */
> @@ -505,8 +505,8 @@ i386_remove_aligned_watchpoint (struct i386_debug_reg_state *state,
>  
>  static int
>  i386_handle_nonaligned_watchpoint (struct i386_debug_reg_state *state,
> -				   i386_wp_op_t what, CORE_ADDR addr, int len,
> -				   enum target_hw_bp_type type)
> +				   i386_wp_op_t what, CORE_ADDR addr,
> +				   ULONGEST len, enum target_hw_bp_type type)
X
>  {
>    int retval = 0;
>    int max_wp_len = TARGET_HAS_DR_LEN_8 ? 8 : 4;
> @@ -663,7 +663,7 @@ i386_remove_watchpoint (CORE_ADDR addr, int len, int type,
>     address ADDR and whose length is LEN bytes.  */
>  
>  static int
> -i386_region_ok_for_watchpoint (CORE_ADDR addr, int len)
> +i386_region_ok_for_watchpoint (CORE_ADDR addr, LONGEST len)
>  {
>    struct i386_debug_reg_state *state = i386_debug_reg_state ();
>    int nregs;
> diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
> index 6858b5a..1d53bf1 100644
> --- a/gdb/i386-tdep.c
> +++ b/gdb/i386-tdep.c
> @@ -2343,7 +2343,7 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    gdb_byte buf[4];
>    int i;
>    int write_pass;
> -  int args_space = 0;
> +  ULONGEST args_space = 0;
X
>  
>    /* Determine the total space required for arguments and struct
>       return address in a first pass (allowing for 16-byte-aligned
> @@ -2351,7 +2351,7 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>  
>    for (write_pass = 0; write_pass < 2; write_pass++)
>      {
> -      int args_space_used = 0;
> +      ULONGEST args_space_used = 0;
X
>        int have_16_byte_aligned_arg = 0;
>  
>        if (struct_return)
> @@ -2369,7 +2369,7 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>  
>        for (i = 0; i < nargs; i++)
>  	{
> -	  int len = TYPE_LENGTH (value_enclosing_type (args[i]));
> +	  ULONGEST len = TYPE_LENGTH (value_enclosing_type (args[i]));
X
>  
>  	  if (write_pass)
>  	    {
> @@ -2444,7 +2444,7 @@ i386_extract_return_value (struct gdbarch *gdbarch, struct type *type,
>  			   struct regcache *regcache, gdb_byte *valbuf)
>  {
>    struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>    gdb_byte buf[I386_MAX_REGISTER_SIZE];
>  
>    if (TYPE_CODE (type) == TYPE_CODE_FLT)
> @@ -2482,8 +2482,8 @@ i386_extract_return_value (struct gdbarch *gdbarch, struct type *type,
>  	}
>        else
>  	internal_error (__FILE__, __LINE__,
> -			_("Cannot extract return value of %d bytes long."),
> -			len);
> +			_("Cannot extract return value of %s bytes long."),
> +			pulongest (len));

It will be plongest then.

>      }
>  }
>  
> @@ -2495,7 +2495,7 @@ i386_store_return_value (struct gdbarch *gdbarch, struct type *type,
>  			 struct regcache *regcache, const gdb_byte *valbuf)
>  {
>    struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    if (TYPE_CODE (type) == TYPE_CODE_FLT)
>      {
> @@ -2547,7 +2547,8 @@ i386_store_return_value (struct gdbarch *gdbarch, struct type *type,
>  	}
>        else
>  	internal_error (__FILE__, __LINE__,
> -			_("Cannot store return value of %d bytes long."), len);
> +			_("Cannot store return value of %s bytes long."),
> +			pulongest (len));

It will be plongest then.

>      }
>  }
>  
> diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c
> index 460345b..e29f97e 100644
> --- a/gdb/ia64-tdep.c
> +++ b/gdb/ia64-tdep.c
> @@ -3269,7 +3269,7 @@ ia64_extract_return_value (struct type *type, struct regcache *regcache,
>        int offset = 0;
>        int regnum = IA64_GR8_REGNUM;
>        int reglen = TYPE_LENGTH (register_type (gdbarch, IA64_GR8_REGNUM));
> -      int n = TYPE_LENGTH (type) / reglen;
> +      ULONGEST n = TYPE_LENGTH (type) / reglen;
X
>        int m = TYPE_LENGTH (type) % reglen;
>  
>        while (n-- > 0)
> @@ -3319,7 +3319,7 @@ ia64_store_return_value (struct type *type, struct regcache *regcache,
>        int offset = 0;
>        int regnum = IA64_GR8_REGNUM;
>        int reglen = TYPE_LENGTH (register_type (gdbarch, IA64_GR8_REGNUM));
> -      int n = TYPE_LENGTH (type) / reglen;
> +      ULONGEST n = TYPE_LENGTH (type) / reglen;
X
>        int m = TYPE_LENGTH (type) % reglen;
>  
>        while (n-- > 0)
> @@ -3725,8 +3725,10 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    int argno;
>    struct value *arg;
>    struct type *type;
> -  int len, argoffset;
> -  int nslots, rseslots, memslots, slotnum, nfuncargs;
> +  ULONGEST argoffset;
X
> +  ULONGEST len;
X
> +  int rseslots, slotnum, nfuncargs;
> +  ULONGEST nslots, memslots;
X
>    int floatreg;
>    ULONGEST bsp;
>    CORE_ADDR funcdescaddr, pc, global_pointer;
> diff --git a/gdb/infcall.c b/gdb/infcall.c
> index 8737c7b..cfc53a7 100644
> --- a/gdb/infcall.c
> +++ b/gdb/infcall.c
> @@ -710,7 +710,7 @@ call_function_by_hand (struct value *function, int nargs, struct value **args)
>  
>    if (struct_return || lang_struct_return)
>      {
> -      int len = TYPE_LENGTH (values_type);
> +      ULONGEST len = TYPE_LENGTH (values_type);
X
>  
>        if (gdbarch_inner_than (gdbarch, 1, 2))
>  	{
> diff --git a/gdb/infrun.c b/gdb/infrun.c
> index ab51806..360a9b7 100644
> --- a/gdb/infrun.c
> +++ b/gdb/infrun.c
> @@ -6710,7 +6710,7 @@ save_infcall_suspend_state (void)
>    if (gdbarch_get_siginfo_type_p (gdbarch))
>      {
>        struct type *type = gdbarch_get_siginfo_type (gdbarch);
> -      size_t len = TYPE_LENGTH (type);
> +      ULONGEST len = TYPE_LENGTH (type);
>        struct cleanup *back_to;
>  
>        siginfo_data = xmalloc (len);
> @@ -6767,11 +6767,10 @@ restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
>    if (inf_state->siginfo_gdbarch == gdbarch)
>      {
>        struct type *type = gdbarch_get_siginfo_type (gdbarch);
> -      size_t len = TYPE_LENGTH (type);
>  
>        /* Errors ignored.  */
>        target_write (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
> -		    inf_state->siginfo_data, 0, len);
> +		    inf_state->siginfo_data, 0, TYPE_LENGTH (type));
>      }
>  
>    /* The inferior can be gone if the user types "print exit(0)"
> diff --git a/gdb/iq2000-tdep.c b/gdb/iq2000-tdep.c
> index dd8ad61..a43cf65 100644
> --- a/gdb/iq2000-tdep.c
> +++ b/gdb/iq2000-tdep.c
> @@ -504,7 +504,7 @@ static void
>  iq2000_store_return_value (struct type *type, struct regcache *regcache,
>  			   const void *valbuf)
>  {
> -  int len = TYPE_LENGTH (type);
> +  LONGEST len = TYPE_LENGTH (type);
>    int regno = E_FN_RETURN_REGNUM;
>  
>    while (len > 0)
> @@ -550,7 +550,7 @@ iq2000_extract_return_value (struct type *type, struct regcache *regcache,
>       returned in a register, and if larger than 8 bytes, it is 
>       returned in a stack location which is pointed to by the same
>       register.  */
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    if (len <= (2 * 4))
>      {
> @@ -578,7 +578,7 @@ iq2000_extract_return_value (struct type *type, struct regcache *regcache,
>        ULONGEST return_buffer;
>        regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
>  				     &return_buffer);
> -      read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
> +      read_memory (return_buffer, valbuf, len);

Redundant for this patch IMO.

>      }
>  }
>  
> @@ -655,8 +655,9 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    const bfd_byte *val;
>    bfd_byte buf[4];
>    struct type *type;
> -  int i, argreg, typelen, slacklen;
> -  int stackspace = 0;
> +  int i, argreg, slacklen;
> +  ULONGEST typelen;
X
> +  ULONGEST stackspace = 0;
X
>    /* Used to copy struct arguments into the stack.  */
>    CORE_ADDR struct_ptr;
>  
> diff --git a/gdb/jv-lang.c b/gdb/jv-lang.c
> index c3c5298..58ed339 100644
> --- a/gdb/jv-lang.c
> +++ b/gdb/jv-lang.c
> @@ -438,7 +438,7 @@ java_link_class_type (struct gdbarch *gdbarch,
>    for (i = TYPE_N_BASECLASSES (type); i < nfields; i++)
>      {
>        int accflags;
> -      int boffset;
> +      LONGEST boffset;
>  
>        if (fields == NULL)
>  	{
> @@ -887,7 +887,7 @@ java_printchar (int c, struct type *type, struct ui_file *stream)
>  static void
>  java_printstr (struct ui_file *stream, struct type *type,
>  	       const gdb_byte *string,
> -	       unsigned int length, const char *encoding, int force_ellipses,
> +	       ULONGEST length, const char *encoding, int force_ellipses,
>  	       const struct value_print_options *options)
>  {
>    const char *type_encoding = java_get_encoding (type);
> diff --git a/gdb/jv-lang.h b/gdb/jv-lang.h
> index 8ea9c3c..bf77ccf 100644
> --- a/gdb/jv-lang.h
> +++ b/gdb/jv-lang.h
> @@ -42,8 +42,8 @@ struct builtin_java_type
>  
>  extern const struct builtin_java_type *builtin_java_type (struct gdbarch *);
>  
> -extern void java_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
> -			    struct ui_file *, int,
> +extern void java_val_print (struct type *, const gdb_byte *, LONGEST,
> +			    CORE_ADDR, struct ui_file *, int,
>  			    const struct value *,
>  			    const struct value_print_options *);
>  
> diff --git a/gdb/jv-valprint.c b/gdb/jv-valprint.c
> index 12a960f..35a55b8 100644
> --- a/gdb/jv-valprint.c
> +++ b/gdb/jv-valprint.c
> @@ -264,7 +264,7 @@ java_value_print (struct value *val, struct ui_file *stream,
>  
>  static void
>  java_print_value_fields (struct type *type, const gdb_byte *valaddr,
> -			 int offset,
> +			 LONGEST offset,
>  			 CORE_ADDR address, struct ui_file *stream,
>  			 int recurse,
>  			 const struct value *val,
> @@ -482,7 +482,7 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr,
>  
>  void
>  java_val_print (struct type *type, const gdb_byte *valaddr,
> -		int embedded_offset, CORE_ADDR address,
> +		LONGEST embedded_offset, CORE_ADDR address,
>  		struct ui_file *stream, int recurse,
>  		const struct value *val,
>  		const struct value_print_options *options)
> diff --git a/gdb/language.c b/gdb/language.c
> index f0a8697..9ae020e 100644
> --- a/gdb/language.c
> +++ b/gdb/language.c
> @@ -831,7 +831,7 @@ unk_lang_printchar (int c, struct type *type, struct ui_file *stream)
>  
>  static void
>  unk_lang_printstr (struct ui_file *stream, struct type *type,
> -		   const gdb_byte *string, unsigned int length,
> +		   const gdb_byte *string, ULONGEST length,
>  		   const char *encoding, int force_ellipses,
>  		   const struct value_print_options *options)
>  {
> @@ -849,7 +849,7 @@ unk_lang_print_type (struct type *type, const char *varstring,
>  
>  static void
>  unk_lang_val_print (struct type *type, const gdb_byte *valaddr,
> -		    int embedded_offset, CORE_ADDR address,
> +		    LONGEST embedded_offset, CORE_ADDR address,
>  		    struct ui_file *stream, int recurse,
>  		    const struct value *val,
>  		    const struct value_print_options *options)
> diff --git a/gdb/language.h b/gdb/language.h
> index d612c70..c571b81 100644
> --- a/gdb/language.h
> +++ b/gdb/language.h
> @@ -200,7 +200,7 @@ struct language_defn
>  			  struct ui_file * stream);
>  
>      void (*la_printstr) (struct ui_file * stream, struct type *elttype,
> -			 const gdb_byte *string, unsigned int length,
> +			 const gdb_byte *string, ULONGEST length,
>  			 const char *encoding, int force_ellipses,
>  			 const struct value_print_options *);
>  
> @@ -242,7 +242,7 @@ struct language_defn
>  
>      void (*la_val_print) (struct type *type,
>  			  const gdb_byte *contents,
> -			  int embedded_offset, CORE_ADDR address,
> +			  LONGEST embedded_offset, CORE_ADDR address,
>  			  struct ui_file *stream, int recurse,
>  			  const struct value *val,
>  			  const struct value_print_options *options);
> diff --git a/gdb/lm32-tdep.c b/gdb/lm32-tdep.c
> index 4f67542..80df079 100644
> --- a/gdb/lm32-tdep.c
> +++ b/gdb/lm32-tdep.c
> @@ -262,7 +262,7 @@ lm32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>        struct value *arg = args[i];
>        struct type *arg_type = check_typedef (value_type (arg));
>        gdb_byte *contents;
> -      int len;
> +      ULONGEST len;
X
>        int j;
>        int reg;
>        ULONGEST val;
> @@ -354,7 +354,7 @@ lm32_store_return_value (struct type *type, struct regcache *regcache,
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    ULONGEST val;
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    if (len <= 4)
>      {
> diff --git a/gdb/m2-lang.c b/gdb/m2-lang.c
> index 8faa6c1..0c9d394 100644
> --- a/gdb/m2-lang.c
> +++ b/gdb/m2-lang.c
> @@ -104,7 +104,7 @@ m2_printchar (int c, struct type *type, struct ui_file *stream)
>  
>  static void
>  m2_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
> -	     unsigned int length, const char *encoding, int force_ellipses,
> +	     ULONGEST length, const char *encoding, int force_ellipses,
>  	     const struct value_print_options *options)
>  {
>    unsigned int i;
> diff --git a/gdb/m2-lang.h b/gdb/m2-lang.h
> index fc6de34..9d65366 100644
> --- a/gdb/m2-lang.h
> +++ b/gdb/m2-lang.h
> @@ -32,7 +32,7 @@ extern void m2_print_typedef (struct type *, struct symbol *,
>  extern int m2_is_long_set (struct type *type);
>  extern int m2_is_unbounded_array (struct type *type);
>  
> -extern void m2_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
> +extern void m2_val_print (struct type *, const gdb_byte *, LONGEST, CORE_ADDR,
>  			  struct ui_file *, int,
>  			  const struct value *,
>  			  const struct value_print_options *);
> diff --git a/gdb/m2-typeprint.c b/gdb/m2-typeprint.c
> index fb3d49c..effe2c9 100644
> --- a/gdb/m2-typeprint.c
> +++ b/gdb/m2-typeprint.c
> @@ -228,9 +228,11 @@ static void m2_array (struct type *type, struct ui_file *stream,
>  	  m2_print_bounds (TYPE_INDEX_TYPE (type), stream, show, -1, 1);
>  	}
>        else
> -	fprintf_filtered (stream, "%d",
> -			  (TYPE_LENGTH (type)
> -			   / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
> +        {
> +	  ULONGEST val = (TYPE_LENGTH (type)
> +			  / TYPE_LENGTH (TYPE_TARGET_TYPE (type)));

Empty line after declaration.

> +	  fprintf_filtered (stream, "%s", pulongest (val));
> +	}
>      }
>    fprintf_filtered (stream, "] OF ");
>    m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
> @@ -587,7 +589,8 @@ m2_record_fields (struct type *type, struct ui_file *stream, int show,
>  void
>  m2_enum (struct type *type, struct ui_file *stream, int show, int level)
>  {
> -  int lastval, i, len;
> +  LONGEST lastval;
> +  int i, len;
>  
>    if (show < 0)
>      {
> diff --git a/gdb/m2-valprint.c b/gdb/m2-valprint.c
> index 9e1c1ff..4d13dad 100644
> --- a/gdb/m2-valprint.c
> +++ b/gdb/m2-valprint.c
> @@ -36,7 +36,7 @@ static int print_unpacked_pointer (struct type *type,
>  				   struct ui_file *stream);
>  static void
>  m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
> -			 int embedded_offset, CORE_ADDR address,
> +			 LONGEST embedded_offset, CORE_ADDR address,
>  			 struct ui_file *stream, int recurse,
>  			 const struct value *val,
>  			 const struct value_print_options *options,
> @@ -68,7 +68,7 @@ get_long_set_bounds (struct type *type, LONGEST *low, LONGEST *high)
>  
>  static void
>  m2_print_long_set (struct type *type, const gdb_byte *valaddr,
> -		   int embedded_offset, CORE_ADDR address,
> +		   LONGEST embedded_offset, CORE_ADDR address,
>  		   struct ui_file *stream)
>  {
>    int empty_set        = 1;
> @@ -159,7 +159,7 @@ m2_print_long_set (struct type *type, const gdb_byte *valaddr,
>  
>  static void
>  m2_print_unbounded_array (struct type *type, const gdb_byte *valaddr,
> -			  int embedded_offset, CORE_ADDR address,
> +			  LONGEST embedded_offset, CORE_ADDR address,
>  			  struct ui_file *stream, int recurse,
>  			  const struct value_print_options *options)
>  {
> @@ -256,22 +256,20 @@ print_variable_at_address (struct type *type,
>  
>  static void
>  m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
> -			 int embedded_offset, CORE_ADDR address,
> +			 LONGEST embedded_offset, CORE_ADDR address,
>  			 struct ui_file *stream, int recurse,
>  			 const struct value *val,
>  			 const struct value_print_options *options,
>  			 int len)
>  {
> -  int eltlen;
>    CHECK_TYPEDEF (type);
>  
>    if (TYPE_LENGTH (type) > 0)
>      {
> -      eltlen = TYPE_LENGTH (type);
>        if (options->prettyprint_arrays)
>  	print_spaces_filtered (2 + 2 * recurse, stream);
>        /* For an array of chars, print with string syntax.  */
> -      if (eltlen == 1 &&
> +      if (TYPE_LENGTH (type) == 1 &&
>  	  ((TYPE_CODE (type) == TYPE_CODE_INT)
>  	   || ((current_language->la_language == language_m2)
>  	       && (TYPE_CODE (type) == TYPE_CODE_CHAR)))
> @@ -304,16 +302,16 @@ static const struct generic_val_print_decorations m2_decorations =
>     function; they are identical.  */
>  
>  void
> -m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
> -	      CORE_ADDR address, struct ui_file *stream, int recurse,
> +m2_val_print (struct type *type, const gdb_byte *valaddr,
> +	      LONGEST embedded_offset, CORE_ADDR address,
> +	      struct ui_file *stream, int recurse,
>  	      const struct value *original_value,
>  	      const struct value_print_options *options)
>  {
>    struct gdbarch *gdbarch = get_type_arch (type);
> -  unsigned int i = 0;	/* Number of characters printed.  */
> -  unsigned len;
> +  ULONGEST i = 0;	/* Number of characters printed.  */
> +  ULONGEST len;
>    struct type *elttype;
> -  unsigned eltlen;
>    LONGEST val;
>    CORE_ADDR addr;
>  
> @@ -324,12 +322,11 @@ m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
>        if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
>  	{
>  	  elttype = check_typedef (TYPE_TARGET_TYPE (type));
> -	  eltlen = TYPE_LENGTH (elttype);
> -	  len = TYPE_LENGTH (type) / eltlen;
> +	  len = TYPE_LENGTH (type) / TYPE_LENGTH (elttype);
>  	  if (options->prettyprint_arrays)
>  	    print_spaces_filtered (2 + 2 * recurse, stream);
>  	  /* For an array of chars, print with string syntax.  */
> -	  if (eltlen == 1 &&
> +	  if (TYPE_LENGTH (elttype) == 1 &&
>  	      ((TYPE_CODE (elttype) == TYPE_CODE_INT)
>  	       || ((current_language->la_language == language_m2)
>  		   && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
> @@ -339,7 +336,7 @@ m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
>  	         elements up to it.  */
>  	      if (options->stop_print_at_null)
>  		{
> -		  unsigned int temp_len;
> +		  ULONGEST temp_len;
>  
>  		  /* Look for a NULL char.  */
>  		  for (temp_len = 0;
> diff --git a/gdb/m32r-tdep.c b/gdb/m32r-tdep.c
> index d504eb3..50d08a9 100644
> --- a/gdb/m32r-tdep.c
> +++ b/gdb/m32r-tdep.c
> @@ -696,7 +696,7 @@ m32r_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    CORE_ADDR regval;
>    gdb_byte *val;
>    gdb_byte valbuf[MAX_REGISTER_SIZE];
> -  int len;
> +  ULONGEST len;
X
>    int odd_sized_struct;
>  
>    /* First force sp to a 4-byte alignment.  */
> @@ -791,7 +791,7 @@ m32r_extract_return_value (struct type *type, struct regcache *regcache,
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    bfd_byte *valbuf = dst;
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>    ULONGEST tmp;
>  
>    /* By using store_unsigned_integer we avoid having to do
> diff --git a/gdb/m68hc11-tdep.c b/gdb/m68hc11-tdep.c
> index 1215de8..e9c3ee9 100644
> --- a/gdb/m68hc11-tdep.c
> +++ b/gdb/m68hc11-tdep.c
> @@ -1174,7 +1174,7 @@ m68hc11_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    int first_stack_argnum;
>    struct type *type;
>    char *val;
> -  int len;
> +  ULONGEST len;
X
>    char buf[2];
>    
>    first_stack_argnum = 0;
> @@ -1266,7 +1266,7 @@ static void
>  m68hc11_store_return_value (struct type *type, struct regcache *regcache,
>                              const void *valbuf)
>  {
> -  int len;
> +  ULONGEST len;
X
>  
>    len = TYPE_LENGTH (type);
>  
> diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c
> index ee72026..a219c72 100644
> --- a/gdb/m68k-tdep.c
> +++ b/gdb/m68k-tdep.c
> @@ -292,7 +292,7 @@ static void
>  m68k_extract_return_value (struct type *type, struct regcache *regcache,
>  			   gdb_byte *valbuf)
>  {
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>    gdb_byte buf[M68K_MAX_REGISTER_SIZE];
>  
>    if (len <= 4)
> @@ -308,14 +308,14 @@ m68k_extract_return_value (struct type *type, struct regcache *regcache,
>      }
>    else
>      internal_error (__FILE__, __LINE__,
> -		    _("Cannot extract return value of %d bytes long."), len);
> +		    _("Cannot extract return value of %s bytes long."),
> +		    pulongest (len));

It will be plongest then.

>  }
>  
>  static void
>  m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache,
>  				gdb_byte *valbuf)
>  {
> -  int len = TYPE_LENGTH (type);
>    gdb_byte buf[M68K_MAX_REGISTER_SIZE];
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
> @@ -326,7 +326,7 @@ m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache,
>        regcache_raw_read (regcache, M68K_FP0_REGNUM, buf);
>        convert_typed_floating (buf, fpreg_type, valbuf, type);
>      }
> -  else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
> +  else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4)
>      regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
>    else
>      m68k_extract_return_value (type, regcache, valbuf);
> @@ -338,7 +338,7 @@ static void
>  m68k_store_return_value (struct type *type, struct regcache *regcache,
>  			 const gdb_byte *valbuf)
>  {
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    if (len <= 4)
>      regcache_raw_write_part (regcache, M68K_D0_REGNUM, 4 - len, len, valbuf);
> @@ -350,14 +350,14 @@ m68k_store_return_value (struct type *type, struct regcache *regcache,
>      }
>    else
>      internal_error (__FILE__, __LINE__,
> -		    _("Cannot store return value of %d bytes long."), len);
> +		    _("Cannot store return value of %s bytes long."),
> +		    pulongest (len));

It will be plongest then.

>  }
>  
>  static void
>  m68k_svr4_store_return_value (struct type *type, struct regcache *regcache,
>  			      const gdb_byte *valbuf)
>  {
> -  int len = TYPE_LENGTH (type);
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
>  
> @@ -368,7 +368,7 @@ m68k_svr4_store_return_value (struct type *type, struct regcache *regcache,
>        convert_typed_floating (valbuf, type, buf, fpreg_type);
>        regcache_raw_write (regcache, M68K_FP0_REGNUM, buf);
>      }
> -  else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
> +  else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4)
>      {
>        regcache_raw_write (regcache, M68K_A0_REGNUM, valbuf);
>        regcache_raw_write (regcache, M68K_D0_REGNUM, valbuf);
> @@ -515,9 +515,9 @@ m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    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;
> +      ULONGEST len = TYPE_LENGTH (value_type);
X
> +      ULONGEST container_len = (len + 3) & ~3;
X
> +      ULONGEST offset;
X
>  
>        /* Non-scalars bigger than 4 bytes are left aligned, others are
>  	 right aligned.  */
> diff --git a/gdb/m88k-tdep.c b/gdb/m88k-tdep.c
> index 1fda594..133be43 100644
> --- a/gdb/m88k-tdep.c
> +++ b/gdb/m88k-tdep.c
> @@ -259,14 +259,14 @@ m88k_store_arguments (struct regcache *regcache, int nargs,
>  		      struct value **args, CORE_ADDR sp)
>  {
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
> -  int num_register_words = 0;
> -  int num_stack_words = 0;
> +  ULONGEST num_register_words = 0;
X
> +  ULONGEST num_stack_words = 0;
X
>    int i;
>  
>    for (i = 0; i < nargs; i++)
>      {
>        struct type *type = value_type (args[i]);
> -      int len = TYPE_LENGTH (type);
> +      ULONGEST len = TYPE_LENGTH (type);
X
>  
>        if (m88k_integral_or_pointer_p (type) && len < 4)
>  	{
> @@ -387,7 +387,7 @@ m88k_return_value (struct gdbarch *gdbarch, struct type *func_type,
>  		   struct type *type, struct regcache *regcache,
>  		   gdb_byte *readbuf, const gdb_byte *writebuf)
>  {
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>    gdb_byte buf[8];
>  
>    if (!m88k_integral_or_pointer_p (type) && !m88k_floating_p (type))
> diff --git a/gdb/memrange.c b/gdb/memrange.c
> index ed41b9a..a655dd5 100644
> --- a/gdb/memrange.c
> +++ b/gdb/memrange.c
> @@ -21,8 +21,8 @@
>  #include "memrange.h"
>  
>  int
> -mem_ranges_overlap (CORE_ADDR start1, int len1,
> -		    CORE_ADDR start2, int len2)
> +mem_ranges_overlap (CORE_ADDR start1, ULONGEST len1,
> +		    CORE_ADDR start2, ULONGEST len2)
X
>  {
>    ULONGEST h, l;
>  
> diff --git a/gdb/memrange.h b/gdb/memrange.h
> index 926af22..e07b962 100644
> --- a/gdb/memrange.h
> +++ b/gdb/memrange.h
> @@ -30,7 +30,7 @@ struct mem_range
>    CORE_ADDR start;
>  
>    /* Length of the range.  */
> -  int length;
> +  ULONGEST length;
X
>  };
>  
>  typedef struct mem_range mem_range_s;
> @@ -40,8 +40,8 @@ DEF_VEC_O(mem_range_s);
>  /* Returns true if the ranges defined by [start1, start1+len1) and
>     [start2, start2+len2) overlap.  */
>  
> -extern int mem_ranges_overlap (CORE_ADDR start1, int len1,
> -			       CORE_ADDR start2, int len2);
> +extern int mem_ranges_overlap (CORE_ADDR start1, ULONGEST len1,
> +			       CORE_ADDR start2, ULONGEST len2);
X
>  
>  /* Sort ranges by start address, then coalesce contiguous or
>     overlapping ranges.  */
> diff --git a/gdb/mep-tdep.c b/gdb/mep-tdep.c
> index fea14bf..287ef25 100644
> --- a/gdb/mep-tdep.c
> +++ b/gdb/mep-tdep.c
> @@ -2279,7 +2279,7 @@ push_large_arguments (CORE_ADDR sp, int argc, struct value **argv,
>  
>    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)
>          {
> @@ -2337,7 +2337,7 @@ mep_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>  
>    for (i = 0; i < argc; i++)
>      {
> -      unsigned arg_size = TYPE_LENGTH (value_type (argv[i]));
> +      ULONGEST arg_size = TYPE_LENGTH (value_type (argv[i]));
>        ULONGEST value;
>  
>        /* Arguments that fit in a GPR get expanded to fill the GPR.  */
> diff --git a/gdb/microblaze-tdep.c b/gdb/microblaze-tdep.c
> index 3ce3d1c..b33c556 100644
> --- a/gdb/microblaze-tdep.c
> +++ b/gdb/microblaze-tdep.c
> @@ -591,7 +591,7 @@ static void
>  microblaze_store_return_value (struct type *type, struct regcache *regcache,
>  			       const gdb_byte *valbuf)
>  {
> -  int len = TYPE_LENGTH (type);
> +  int ULONGEST len = TYPE_LENGTH (type);

This is some typo.  And it should be LONGEST.

>    gdb_byte buf[8];
>  
>    memset (buf, 0, sizeof(buf));
> diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c
> index 9a3c7fb..8c4440d 100644
> --- a/gdb/mips-tdep.c
> +++ b/gdb/mips-tdep.c
> @@ -302,7 +302,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;
>  
> @@ -325,8 +325,8 @@ mips_xfer_register (struct gdbarch *gdbarch, struct regcache *regcache,
>      }
>    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;
> @@ -3078,13 +3078,13 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>        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);
> +      ULONGEST len = TYPE_LENGTH (arg_type);
X
>        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, pulongest (len), (int) typecode);

It will be plongest then.

>  
>        /* Function pointer arguments to mips16 code need to be made into
>           mips16 pointers.  */
> @@ -3369,7 +3369,7 @@ mips_eabi_return_value (struct gdbarch *gdbarch, struct type *func_type,
>  
>  static int
>  mips_n32n64_fp_arg_chunk_p (struct gdbarch *gdbarch, struct type *arg_type,
> -			    int offset)
> +			    LONGEST offset)
>  {
>    int i;
>  
> @@ -3384,7 +3384,7 @@ mips_n32n64_fp_arg_chunk_p (struct gdbarch *gdbarch, struct type *arg_type,
>  
>    for (i = 0; i < TYPE_NFIELDS (arg_type); i++)
>      {
> -      int pos;
> +      LONGEST pos;
>        struct type *field_type;
>  
>        /* We're only looking at normal fields.  */
> @@ -3778,11 +3778,11 @@ mips_n32n64_return_value (struct gdbarch *gdbarch, struct type *func_type,
>  				: 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
> @@ -3869,7 +3869,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    int argreg;
>    int float_argreg;
>    int argnum;
> -  int len = 0;
> +  ULONGEST len = 0;
X
>    int stack_offset = 0;
>    struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
> @@ -3896,13 +3896,12 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    for (argnum = 0; argnum < nargs; argnum++)
>      {
>        struct type *arg_type = check_typedef (value_type (args[argnum]));
> -      int arglen = TYPE_LENGTH (arg_type);
>  
>        /* Align to double-word if necessary.  */
>        if (mips_type_needs_double_align (arg_type))
>  	len = align_up (len, MIPS32_REGSIZE * 2);
>        /* Allocate space on the stack.  */
> -      len += align_up (arglen, MIPS32_REGSIZE);
> +      len += align_up (TYPE_LENGTH (arg_type), MIPS32_REGSIZE);
>      }
>    sp -= align_up (len, 16);
>  
> @@ -3935,13 +3934,13 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>        const gdb_byte *val;
>        struct value *arg = args[argnum];
>        struct type *arg_type = check_typedef (value_type (arg));
> -      int len = TYPE_LENGTH (arg_type);
> +      ULONGEST len = TYPE_LENGTH (arg_type);
X
>        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, pulongest (len), (int) typecode);

It will be plongest then.

>  
>        val = value_contents (arg);
>  
> @@ -4337,8 +4336,8 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    int argreg;
>    int float_argreg;
>    int argnum;
> -  int len = 0;
> -  int stack_offset = 0;
> +  ULONGEST len = 0;
X
> +  ULONGEST stack_offset = 0;
X
>    struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    CORE_ADDR func_addr = find_function_addr (function, NULL);
> @@ -4364,10 +4363,9 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    for (argnum = 0; argnum < nargs; argnum++)
>      {
>        struct type *arg_type = check_typedef (value_type (args[argnum]));
> -      int arglen = TYPE_LENGTH (arg_type);
>  
>        /* Allocate space on the stack.  */
> -      len += align_up (arglen, MIPS64_REGSIZE);
> +      len += align_up (TYPE_LENGTH (arg_type), MIPS64_REGSIZE);
>      }
>    sp -= align_up (len, 16);
>  
> @@ -4401,13 +4399,13 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>        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);
> +      ULONGEST len = TYPE_LENGTH (arg_type);
X
>        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, pulongest (len), (int) typecode);

THis will be plongest then.

>  
>        val = value_contents (arg);
>  
> diff --git a/gdb/mn10300-tdep.c b/gdb/mn10300-tdep.c
> index 116a03e..ee68407 100644
> --- a/gdb/mn10300-tdep.c
> +++ b/gdb/mn10300-tdep.c
> @@ -83,10 +83,11 @@ struct mn10300_prologue
>  
>  /* Compute the alignment required by a type.  */
>  
> -static int
> +static ULONGEST
X
>  mn10300_type_align (struct type *type)
>  {
> -  int i, align = 1;
> +  int i;
> +  ULONGEST align = 1;
X
>  
>    switch (TYPE_CODE (type))
>      {
> @@ -108,7 +109,7 @@ mn10300_type_align (struct type *type)
>      case TYPE_CODE_UNION:
>        for (i = 0; i < TYPE_NFIELDS (type); i++)
>  	{
> -	  int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
> +	  ULONGEST falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
X
>  	  while (align < falign)
>  	    align <<= 1;
>  	}
> @@ -1228,7 +1229,7 @@ mn10300_push_dummy_call (struct gdbarch *gdbarch,
>    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; 
> +  ULONGEST len, arg_len;
X
>    int stack_offset = 0;
>    int argnum;
>    char *val, valbuf[MAX_REGISTER_SIZE];
> diff --git a/gdb/moxie-tdep.c b/gdb/moxie-tdep.c
> index 1f5f33f..43e2e69 100644
> --- a/gdb/moxie-tdep.c
> +++ b/gdb/moxie-tdep.c
> @@ -124,7 +124,7 @@ moxie_store_return_value (struct type *type, struct regcache *regcache,
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    CORE_ADDR regval;
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    /* Things always get returned in RET1_REGNUM, RET2_REGNUM.  */
>    regval = extract_unsigned_integer (valbuf, len > 4 ? 4 : len, byte_order);
> @@ -321,7 +321,7 @@ moxie_extract_return_value (struct type *type, struct regcache *regcache,
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    bfd_byte *valbuf = dst;
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>    ULONGEST tmp;
>  
>    /* By using store_unsigned_integer we avoid having to do
> diff --git a/gdb/mt-tdep.c b/gdb/mt-tdep.c
> index 268be86..fa277f4 100644
> --- a/gdb/mt-tdep.c
> +++ b/gdb/mt-tdep.c
> @@ -783,9 +783,9 @@ mt_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    gdb_byte buf[MT_MAX_STRUCT_SIZE];
>    int argreg = MT_1ST_ARGREG;
>    int split_param_len = 0;
> -  int stack_dest = sp;
> +  ULONGEST stack_dest = sp;
X
>    int slacklen;
> -  int typelen;
> +  ULONGEST typelen;
X
>    int i, j;
>  
>    /* First handle however many args we can fit into MT_1ST_ARGREG thru
> diff --git a/gdb/objc-lang.c b/gdb/objc-lang.c
> index 15bf792..f0462f8 100644
> --- a/gdb/objc-lang.c
> +++ b/gdb/objc-lang.c
> @@ -347,7 +347,7 @@ objc_printchar (int c, struct type *type, struct ui_file *stream)
>  
>  static void
>  objc_printstr (struct ui_file *stream, struct type *type,
> -	       const gdb_byte *string, unsigned int length,
> +	       const gdb_byte *string, ULONGEST length,
>  	       const char *encoding, int force_ellipses,
>  	       const struct value_print_options *options)
>  {
> diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c
> index 54075a4..ef74f48 100644
> --- a/gdb/opencl-lang.c
> +++ b/gdb/opencl-lang.c
> @@ -80,11 +80,11 @@ builtin_opencl_type (struct gdbarch *gdbarch)
>  
>  static struct type *
>  lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code,
> -			   unsigned int el_length, unsigned int flag_unsigned,
> +			   ULONGEST el_length, unsigned int flag_unsigned,
>  			   int n)
>  {
>    int i;
> -  unsigned int length;
> +  ULONGEST length;
>    struct type *type = NULL;
>    struct type **types = builtin_opencl_type (gdbarch);
>  
> @@ -174,9 +174,9 @@ lval_func_read (struct value *v)
>    struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
>    struct type *type = check_typedef (value_type (v));
>    struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
> -  int offset = value_offset (v);
> -  int elsize = TYPE_LENGTH (eltype);
> -  int n, i, j = 0;
> +  LONGEST offset = value_offset (v);
> +  ULONGEST elsize = TYPE_LENGTH (eltype);
X
> +  LONGEST n, i, j = 0;
>    LONGEST lowb = 0;
>    LONGEST highb = 0;
>  
> @@ -203,9 +203,9 @@ lval_func_write (struct value *v, struct value *fromval)
>    struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
>    struct type *type = check_typedef (value_type (v));
>    struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
> -  int offset = value_offset (v);
> -  int elsize = TYPE_LENGTH (eltype);
> -  int n, i, j = 0;
> +  LONGEST offset = value_offset (v);
> +  ULONGEST elsize = TYPE_LENGTH (eltype);
X
> +  LONGEST n, i, j = 0;
>    LONGEST lowb = 0;
>    LONGEST highb = 0;
>  
> @@ -243,17 +243,18 @@ lval_func_write (struct value *v, struct value *fromval)
>  /* Return nonzero if all bits in V within OFFSET and LENGTH are valid.  */
>  
>  static int
> -lval_func_check_validity (const struct value *v, int offset, int length)
> +lval_func_check_validity (const struct value *v, LONGEST offset,
> +			  ULONGEST length)
X
>  {
>    struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
>    /* Size of the target type in bits.  */
> -  int elsize =
> -      TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
> +  ULONGEST elsize =
X
> +	   TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
>    int startrest = offset % elsize;
> -  int start = offset / elsize;
> +  LONGEST start = offset / elsize;
>    int endrest = (offset + length) % elsize;
> -  int end = (offset + length) / elsize;
> -  int i;
> +  LONGEST end = (offset + length) / elsize;
> +  LONGEST i;
>  
>    if (endrest)
>      end++;
> @@ -281,8 +282,8 @@ lval_func_check_any_valid (const struct value *v)
>  {
>    struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
>    /* Size of the target type in bits.  */
> -  int elsize =
> -      TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
> +  ULONGEST elsize =
X
> +	   TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
>    int i;
>  
>    for (i = 0; i < c->n; i++)
> @@ -297,17 +298,17 @@ lval_func_check_any_valid (const struct value *v)
>  
>  static int
>  lval_func_check_synthetic_pointer (const struct value *v,
> -				   int offset, int length)
> +				   LONGEST offset, ULONGEST length)
X
>  {
>    struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
>    /* Size of the target type in bits.  */
> -  int elsize =
> -      TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
> +  ULONGEST elsize =
X
> +	   TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
>    int startrest = offset % elsize;
> -  int start = offset / elsize;
> +  LONGEST start = offset / elsize;
>    int endrest = (offset + length) % elsize;
> -  int end = (offset + length) / elsize;
> -  int i;
> +  LONGEST end = (offset + length) / elsize;
> +  LONGEST i;
>  
>    if (endrest)
>      end++;
> diff --git a/gdb/p-lang.c b/gdb/p-lang.c
> index c59ba0b..94f4ad6 100644
> --- a/gdb/p-lang.c
> +++ b/gdb/p-lang.c
> @@ -96,8 +96,8 @@ pascal_main_name (void)
>     are not multiple of TARGET_CHAR_BIT then the results are wrong
>     but this does not happen for Free Pascal nor for GPC.  */
>  int
> -is_pascal_string_type (struct type *type,int *length_pos,
> -                       int *length_size, int *string_pos,
> +is_pascal_string_type (struct type *type, LONGEST *length_pos,
> +		       ULONGEST *length_size, LONGEST *string_pos,
X
>  		       struct type **char_type,
>  		       const char **arrayname)
>  {
> @@ -217,7 +217,7 @@ pascal_printchar (int c, struct type *type, struct ui_file *stream)
>  
>  void
>  pascal_printstr (struct ui_file *stream, struct type *type,
> -		 const gdb_byte *string, unsigned int length,
> +		 const gdb_byte *string, ULONGEST length,
>  		 const char *encoding, int force_ellipses,
>  		 const struct value_print_options *options)
>  {
> diff --git a/gdb/p-lang.h b/gdb/p-lang.h
> index b1e218c..32abab2 100644
> --- a/gdb/p-lang.h
> +++ b/gdb/p-lang.h
> @@ -35,7 +35,7 @@ extern void pascal_print_type (struct type *, const char *, struct ui_file *,
>  extern void pascal_print_typedef (struct type *, struct symbol *,
>  				  struct ui_file *);
>  
> -extern void pascal_val_print (struct type *, const gdb_byte *, int,
> +extern void pascal_val_print (struct type *, const gdb_byte *, LONGEST,
>  			      CORE_ADDR, struct ui_file *, int,
>  			      const struct value *,
>  			      const struct value_print_options *);
> @@ -49,13 +49,13 @@ extern void pascal_type_print_method_args (const char *, const char *,
>  /* These are in p-lang.c: */
>  
>  extern int
> -  is_pascal_string_type (struct type *, int *, int *, int *,
> +  is_pascal_string_type (struct type *, LONGEST *, ULONGEST *, LONGEST *,
X
>  			 struct type **, const char **);
>  
>  extern void pascal_printchar (int, struct type *, struct ui_file *);
>  
>  extern void pascal_printstr (struct ui_file *, struct type *, const gdb_byte *,
> -			     unsigned int, const char *, int,
> +			     ULONGEST, const char *, int,
>  			     const struct value_print_options *);
>  
>  extern struct type **const (pascal_builtin_types[]);
> @@ -69,7 +69,7 @@ extern void
>    pascal_type_print_varspec_prefix (struct type *, struct ui_file *, int, int);
>  
>  extern void pascal_object_print_value_fields (struct type *, const gdb_byte *,
> -					      int,
> +					      LONGEST,
>  					      CORE_ADDR, struct ui_file *,
>  					      int,
>  					      const struct value *,
> diff --git a/gdb/p-typeprint.c b/gdb/p-typeprint.c
> index a00f5b3..828b0ce 100644
> --- a/gdb/p-typeprint.c
> +++ b/gdb/p-typeprint.c
> @@ -442,7 +442,7 @@ pascal_type_print_base (struct type *type, struct ui_file *stream, int show,
>  {
>    int i;
>    int len;
> -  int lastval;
> +  LONGEST lastval;
>    enum
>      {
>        s_none, s_public, s_private, s_protected
> diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c
> index d6373ae..807f396 100644
> --- a/gdb/p-valprint.c
> +++ b/gdb/p-valprint.c
> @@ -58,7 +58,7 @@ static const struct generic_val_print_decorations p_decorations =
>  
>  void
>  pascal_val_print (struct type *type, const gdb_byte *valaddr,
> -		  int embedded_offset, CORE_ADDR address,
> +		  LONGEST embedded_offset, CORE_ADDR address,
>  		  struct ui_file *stream, int recurse,
>  		  const struct value *original_value,
>  		  const struct value_print_options *options)
> @@ -69,8 +69,9 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
>    unsigned len;
>    LONGEST low_bound, high_bound;
>    struct type *elttype;
> -  unsigned eltlen;
> -  int length_pos, length_size, string_pos;
> +  ULONGEST eltlen;
> +  LONGEST length_pos, string_pos;
> +  ULONGEST length_size;
X
>    struct type *char_type;
>    LONGEST val;
>    CORE_ADDR addr;
> @@ -464,7 +465,7 @@ static void pascal_object_print_static_field (struct value *,
>  					      const struct value_print_options *);
>  
>  static void pascal_object_print_value (struct type *, const gdb_byte *,
> -				       int,
> +				       LONGEST,
>  				       CORE_ADDR, struct ui_file *, int,
>  				       const struct value *,
>  				       const struct value_print_options *,
> @@ -523,7 +524,7 @@ pascal_object_is_vtbl_member (struct type *type)
>  
>  void
>  pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
> -				  int offset,
> +				  LONGEST offset,
>  				  CORE_ADDR address, struct ui_file *stream,
>  				  int recurse,
>  				  const struct value *val,
> @@ -718,7 +719,7 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
>  
>  static void
>  pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
> -			   int offset,
> +			   LONGEST offset,
>  			   CORE_ADDR address, struct ui_file *stream,
>  			   int recurse,
>  			   const struct value *val,
> @@ -741,11 +742,11 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
>  
>    for (i = 0; i < n_baseclasses; i++)
>      {
> -      int boffset = 0;
> +      LONGEST boffset = 0;
>        struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
>        const char *basename = type_name_no_tag (baseclass);
>        const gdb_byte *base_valaddr = NULL;
> -      int thisoffset;
> +      LONGEST thisoffset;
>        volatile struct gdb_exception ex;
>        int skip = 0;
>  
> diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c
> index 9bd11fd..ca58089 100644
> --- a/gdb/ppc-linux-nat.c
> +++ b/gdb/ppc-linux-nat.c
> @@ -1927,7 +1927,7 @@ num_memory_accesses (struct value *v)
>     of the constant.  */
>  static int
>  check_condition (CORE_ADDR watch_addr, struct expression *cond,
> -		 CORE_ADDR *data_value, int *len)
> +		 CORE_ADDR *data_value, ULONGEST *len)
X
>  {
>    int pc = 1, num_accesses_left, num_accesses_right;
>    struct value *left_val, *right_val, *left_chain, *right_chain;
> diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c
> index 20598d0..8623c14 100644
> --- a/gdb/ppc-sysv-tdep.c
> +++ b/gdb/ppc-sysv-tdep.c
> @@ -100,9 +100,9 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>        /* 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;
> +      ULONGEST argoffset = 2 * tdep->wordsize;
X
>        /* Structures start after the arguments.  */
> -      int structoffset = argoffset + argspace;
> +      ULONGEST structoffset = argoffset + argspace;
X
>  
>        /* If the function is returning a `struct', then the first word
>           (which will be passed in r3) is used for struct return
> @@ -121,7 +121,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>  	{
>  	  struct value *arg = args[argno];
>  	  struct type *type = check_typedef (value_type (arg));
> -	  int len = TYPE_LENGTH (type);
> +	  ULONGEST len = TYPE_LENGTH (type);
X
>  	  const bfd_byte *val = value_contents (arg);
>  
>  	  if (TYPE_CODE (type) == TYPE_CODE_FLT && len <= 8
> @@ -353,7 +353,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>  	      /* OpenCL vectors shorter than 16 bytes are passed as if
>  		 a series of independent scalars.  */
>  	      struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
> -	      int i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
> +	      ULONGEST i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
X
>  
>  	      for (i = 0; i < nelt; i++)
>  		{
> @@ -841,11 +841,11 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
>        && opencl_abi)
>      {
>        struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
> -      int i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
> +      ULONGEST i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
X
>  
>        for (i = 0; i < nelt; i++)
>  	{
> -	  int offset = i * TYPE_LENGTH (eltype);
> +	  ULONGEST offset = i * TYPE_LENGTH (eltype);
X
>  
>  	  if (TYPE_CODE (eltype) == TYPE_CODE_FLT)
>  	    {
> @@ -1591,7 +1591,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch,
>  		     register.  Work around this by always writing the
>  		     value to memory.  Fortunately, doing this
>  		     simplifies the code.  */
> -		  int len = TYPE_LENGTH (type);
> +		  ULONGEST len = TYPE_LENGTH (type);
X
>  		  if (len < tdep->wordsize)
>  		    write_memory (gparam + tdep->wordsize - len, val, len);
>  		  else
> @@ -1840,12 +1840,12 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *func_type,
>        && TYPE_LENGTH (valtype) >= 16
>        && opencl_abi)
>      {
> -      int n_regs = TYPE_LENGTH (valtype) / 16;
> -      int i;
> +      ULONGEST n_regs = TYPE_LENGTH (valtype) / 16;
X
> +      ULONGEST i;
X
>  
>        for (i = 0; i < n_regs; i++)
>  	{
> -	  int offset = i * 16;
> +	  ULONGEST offset = i * 16;
X
>  	  int regnum = tdep->ppc_vr0_regnum + 2 + i;
>  
>  	  if (writebuf != NULL)
> diff --git a/gdb/printcmd.c b/gdb/printcmd.c
> index d441dfe..639bc97 100644
> --- a/gdb/printcmd.c
> +++ b/gdb/printcmd.c
> @@ -296,7 +296,7 @@ print_formatted (struct value *val, int size,
>  		 struct ui_file *stream)
>  {
>    struct type *type = check_typedef (value_type (val));
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    if (VALUE_LVAL (val) == lval_memory)
>      next_address = value_address (val) + len;
> @@ -352,7 +352,7 @@ float_type_from_length (struct type *type)
>  {
>    struct gdbarch *gdbarch = get_type_arch (type);
>    const struct builtin_type *builtin = builtin_type (gdbarch);
> -  unsigned int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
>  
>    if (len == TYPE_LENGTH (builtin->builtin_float))
>      type = builtin->builtin_float;
> @@ -375,7 +375,7 @@ print_scalar_formatted (const void *valaddr, struct type *type,
>  {
>    struct gdbarch *gdbarch = get_type_arch (type);
>    LONGEST val_long = 0;
> -  unsigned int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>  
>    /* String printing should go through val_print_scalar_formatted.  */
> diff --git a/gdb/python/py-prettyprint.c b/gdb/python/py-prettyprint.c
> index 86d4f2c..1ceb23b 100644
> --- a/gdb/python/py-prettyprint.c
> +++ b/gdb/python/py-prettyprint.c
> @@ -676,7 +676,7 @@ print_children (PyObject *printer, const char *hint,
>  
>  int
>  apply_val_pretty_printer (struct type *type, const gdb_byte *valaddr,
> -			  int embedded_offset, CORE_ADDR address,
> +			  LONGEST embedded_offset, CORE_ADDR address,
>  			  struct ui_file *stream, int recurse,
>  			  const struct value *val,
>  			  const struct value_print_options *options,
> @@ -824,7 +824,7 @@ gdbpy_default_visualizer (PyObject *self, PyObject *args)
>  
>  int
>  apply_val_pretty_printer (struct type *type, const gdb_byte *valaddr,
> -			  int embedded_offset, CORE_ADDR address,
> +			  LONGEST embedded_offset, CORE_ADDR address,
>  			  struct ui_file *stream, int recurse,
>  			  const struct value *val,
>  			  const struct value_print_options *options,
> diff --git a/gdb/python/python.h b/gdb/python/python.h
> index dd7066f..2a57409 100644
> --- a/gdb/python/python.h
> +++ b/gdb/python/python.h
> @@ -31,7 +31,7 @@ void eval_python_from_control_command (struct command_line *);
>  void source_python_script (FILE *file, const char *filename);
>  
>  int apply_val_pretty_printer (struct type *type, const gdb_byte *valaddr,
> -			      int embedded_offset, CORE_ADDR address,
> +			      LONGEST embedded_offset, CORE_ADDR address,
>  			      struct ui_file *stream, int recurse,
>  			      const struct value *val,
>  			      const struct value_print_options *options,
> diff --git a/gdb/regcache.c b/gdb/regcache.c
> index c716280..12ed8fa 100644
> --- a/gdb/regcache.c
> +++ b/gdb/regcache.c
> @@ -902,7 +902,7 @@ typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
>  
>  static enum register_status
>  regcache_xfer_part (struct regcache *regcache, int regnum,
> -		    int offset, int len, void *in, const void *out,
> +		    LONGEST offset, int len, void *in, const void *out,
>  		    enum register_status (*read) (struct regcache *regcache,
>  						  int regnum,
>  						  gdb_byte *buf),
> @@ -968,7 +968,7 @@ regcache_raw_write_part (struct regcache *regcache, int regnum,
>  
>  enum register_status
>  regcache_cooked_read_part (struct regcache *regcache, int regnum,
> -			   int offset, int len, gdb_byte *buf)
> +			   LONGEST offset, int len, gdb_byte *buf)
>  {
>    struct regcache_descr *descr = regcache->descr;
>  
> @@ -979,7 +979,7 @@ regcache_cooked_read_part (struct regcache *regcache, int regnum,
>  
>  void
>  regcache_cooked_write_part (struct regcache *regcache, int regnum,
> -			    int offset, int len, const gdb_byte *buf)
> +			    LONGEST offset, int len, const gdb_byte *buf)
>  {
>    struct regcache_descr *descr = regcache->descr;
>  
> diff --git a/gdb/regcache.h b/gdb/regcache.h
> index 93b4499..81ccda6 100644
> --- a/gdb/regcache.h
> +++ b/gdb/regcache.h
> @@ -129,10 +129,10 @@ extern void regcache_cooked_write_unsigned (struct regcache *regcache,
>     write style operations.  */
>  
>  enum register_status regcache_cooked_read_part (struct regcache *regcache,
> -						int regnum, int offset,
> +						int regnum, LONGEST offset,
>  						int len, gdb_byte *buf);
>  void regcache_cooked_write_part (struct regcache *regcache, int regnum,
> -				 int offset, int len, const gdb_byte *buf);
> +				 LONGEST offset, int len, const gdb_byte *buf);
>  
>  /* Special routines to read/write the PC.  */
>  
> diff --git a/gdb/remote.c b/gdb/remote.c
> index 68864d1..995afe7 100644
> --- a/gdb/remote.c
> +++ b/gdb/remote.c
> @@ -6450,7 +6450,7 @@ check_binary_download (CORE_ADDR addr)
>  
>  static int
>  remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
> -			const gdb_byte *myaddr, int len,
> +			const gdb_byte *myaddr, LONGEST len,
>  			char packet_format, int use_length)
>  {
>    struct remote_state *rs = get_remote_state ();
> @@ -6611,7 +6611,7 @@ remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
>     error.  Only transfer a single packet.  */
>  
>  static int
> -remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
> +remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, LONGEST len)
>  {
>    char *packet_format = 0;
>  
> @@ -8034,7 +8034,7 @@ int remote_hw_watchpoint_length_limit = -1;
>  int remote_hw_breakpoint_limit = -1;
>  
>  static int
> -remote_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
> +remote_region_ok_for_hw_watchpoint (CORE_ADDR addr, LONGEST len)
>  {
>    if (remote_hw_watchpoint_length_limit == 0)
>      return 0;
> diff --git a/gdb/rl78-tdep.c b/gdb/rl78-tdep.c
> index 7a84769..a8b3f6a 100644
> --- a/gdb/rl78-tdep.c
> +++ b/gdb/rl78-tdep.c
> @@ -1019,9 +1019,8 @@ rl78_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    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;
> -      int offset;
> +      ULONGEST len = TYPE_LENGTH (value_type);
X
> +      ULONGEST container_len = (len + 1) & ~1;
X
>  
>        sp -= container_len;
>        write_memory (rl78_make_data_address (sp),
> diff --git a/gdb/rs6000-aix-tdep.c b/gdb/rs6000-aix-tdep.c
> index 5531326..0df6483 100644
> --- a/gdb/rs6000-aix-tdep.c
> +++ b/gdb/rs6000-aix-tdep.c
> @@ -197,7 +197,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    int ii;
> -  int len = 0;
> +  ULONGEST len = 0;
X
>    int argno;			/* current argument number */
>    int argbytes;			/* current argument byte */
>    gdb_byte tmp_buffer[50];
> @@ -327,7 +327,7 @@ ran_out_of_registers_for_arguments:
>  
>    if ((argno < nargs) || argbytes)
>      {
> -      int space = 0, jj;
> +      ULONGEST space = 0, jj;
X
>  
>        if (argbytes)
>  	{
> diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
> index 038a3ce..7ff02ac 100644
> --- a/gdb/s390-tdep.c
> +++ b/gdb/s390-tdep.c
> @@ -376,9 +376,9 @@ s390_value_from_register (struct type *type, int regnum,
>  			  struct frame_info *frame)
>  {
>    struct value *value = default_value_from_register (type, regnum, frame);
> -  int len = TYPE_LENGTH (check_typedef (type));
>  
> -  if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM && len < 8)
> +  if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM &&
> +      TYPE_LENGTH (check_typedef (type))< 8)

I would not do this simplification, check_typedef is pretty invasive function,
it is more usual to keep it in the declarations or even on a separate
statement line.


>      set_value_offset (value, 0);
>  
>    return value;
> @@ -2490,8 +2490,7 @@ is_power_of_two (unsigned int n)
>  static int
>  s390_function_arg_pass_by_reference (struct type *type)
>  {
> -  unsigned length = TYPE_LENGTH (type);
> -  if (length > 8)
> +  if (TYPE_LENGTH (type) > 8)
>      return 1;
>  
>    return (is_struct_like (type) && !is_power_of_two (TYPE_LENGTH (type)))
> @@ -2504,8 +2503,7 @@ s390_function_arg_pass_by_reference (struct type *type)
>  static int
>  s390_function_arg_float (struct type *type)
>  {
> -  unsigned length = TYPE_LENGTH (type);
> -  if (length > 8)
> +  if (TYPE_LENGTH (type) > 8)
>      return 0;
>  
>    return is_float_like (type);
> @@ -2617,11 +2615,10 @@ s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>      {
>        struct value *arg = args[i];
>        struct type *type = check_typedef (value_type (arg));
> -      unsigned length = TYPE_LENGTH (type);
>  
>        if (s390_function_arg_pass_by_reference (type))
>          {
> -          sp -= length;
> +          sp -= TYPE_LENGTH (type);
>            sp = align_down (sp, alignment_of (type));
>            copy_addr[i] = sp;
>          }
> @@ -2670,7 +2667,7 @@ s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>        {
>          struct value *arg = args[i];
>          struct type *type = check_typedef (value_type (arg));
> -        unsigned length = TYPE_LENGTH (type);
> +        ULONGEST length = TYPE_LENGTH (type);
>  
>  	if (s390_function_arg_pass_by_reference (type))
>  	  {
> @@ -2800,8 +2797,7 @@ s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
>  static enum return_value_convention
>  s390_return_value_convention (struct gdbarch *gdbarch, struct type *type)
>  {
> -  int length = TYPE_LENGTH (type);
> -  if (length > 8)
> +  if (TYPE_LENGTH (type) > 8)
>      return RETURN_VALUE_STRUCT_CONVENTION;
>  
>    switch (TYPE_CODE (type))
> @@ -2825,7 +2821,7 @@ s390_return_value (struct gdbarch *gdbarch, struct type *func_type,
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    int word_size = gdbarch_ptr_bit (gdbarch) / 8;
>    enum return_value_convention rvc;
> -  int length;
> +  ULONGEST length;
X
>  
>    type = check_typedef (type);
>    rvc = s390_return_value_convention (gdbarch, type);
> diff --git a/gdb/score-tdep.c b/gdb/score-tdep.c
> index 90ef610..530f876 100644
> --- a/gdb/score-tdep.c
> +++ b/gdb/score-tdep.c
> @@ -516,7 +516,7 @@ score_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    int argnum;
>    int argreg;
> -  int arglen = 0;
> +  ULONGEST arglen = 0;
X
>    CORE_ADDR stack_offset = 0;
>    CORE_ADDR addr = 0;
>  
> diff --git a/gdb/sh-tdep.c b/gdb/sh-tdep.c
> index 7f15191..73822b2 100644
> --- a/gdb/sh-tdep.c
> +++ b/gdb/sh-tdep.c
> @@ -1308,7 +1308,7 @@ sh_extract_return_value_nofpu (struct type *type, struct regcache *regcache,
>  {
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>    int return_register = R0_REGNUM;
>    int offset;
>  
> @@ -1362,7 +1362,7 @@ sh_store_return_value_nofpu (struct type *type, struct regcache *regcache,
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    ULONGEST val;
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    if (len <= 4)
>      {
> diff --git a/gdb/sh64-tdep.c b/gdb/sh64-tdep.c
> index 2e5d8bd..181892c 100644
> --- a/gdb/sh64-tdep.c
> +++ b/gdb/sh64-tdep.c
> @@ -1059,7 +1059,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
>  		      CORE_ADDR struct_addr)
>  {
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
> -  int stack_offset, stack_alloc;
> +  ULONGEST stack_offset, stack_alloc;
X
>    int int_argreg;
>    int float_argreg;
>    int double_argreg;
> @@ -1071,7 +1071,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
>    char *val;
>    char valbuf[8];
>    char valbuf_tmp[8];
> -  int len;
> +  ULONGEST len;
X
>    int argreg_size;
>    int fp_args[12];
>  
> @@ -1230,7 +1230,7 @@ sh64_extract_return_value (struct type *type, struct regcache *regcache,
>  {
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    if (TYPE_CODE (type) == TYPE_CODE_FLT)
>      {
> @@ -1292,7 +1292,7 @@ sh64_store_return_value (struct type *type, struct regcache *regcache,
>  {
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    char buf[64];	/* more than enough...  */
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    if (TYPE_CODE (type) == TYPE_CODE_FLT)
>      {
> diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c
> index 00bca01..fb363d5 100644
> --- a/gdb/sparc-tdep.c
> +++ b/gdb/sparc-tdep.c
> @@ -470,7 +470,7 @@ sparc32_store_arguments (struct regcache *regcache, int nargs,
>    for (i = 0; i < nargs; i++)
>      {
>        struct type *type = value_type (args[i]);
> -      int len = TYPE_LENGTH (type);
> +      ULONGEST len = TYPE_LENGTH (type);
X
>  
>        if (sparc_structure_or_union_p (type)
>  	  || (sparc_floating_p (type) && len == 16)
> diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c
> index f30022e..a9a2935 100644
> --- a/gdb/sparc64-tdep.c
> +++ b/gdb/sparc64-tdep.c
> @@ -639,7 +639,8 @@ sparc64_16_byte_align_p (struct type *type)
>  
>  static void
>  sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
> -			       const gdb_byte *valbuf, int element, int bitpos)
> +			       const gdb_byte *valbuf, int element,
> +			       LONGEST bitpos)
>  {
>    int len = TYPE_LENGTH (type);
>  
> @@ -681,7 +682,7 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
>        for (i = 0; i < TYPE_NFIELDS (type); i++)
>  	{
>  	  struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
> -	  int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
> +	  LONGEST subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
>  
>  	  sparc64_store_floating_fields (regcache, subtype, valbuf,
>  					 element, subpos);
> @@ -713,7 +714,7 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
>  
>  static void
>  sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
> -				 gdb_byte *valbuf, int bitpos)
> +				 gdb_byte *valbuf, LONGEST bitpos)
>  {
>    if (sparc64_floating_p (type))
>      {
> @@ -750,7 +751,7 @@ sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
>        for (i = 0; i < TYPE_NFIELDS (type); i++)
>  	{
>  	  struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
> -	  int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
> +	  LONGEST subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
>  
>  	  sparc64_extract_floating_fields (regcache, subtype, valbuf, subpos);
>  	}
> @@ -783,7 +784,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
>    for (i = 0; i < nargs; i++)
>      {
>        struct type *type = value_type (args[i]);
> -      int len = TYPE_LENGTH (type);
> +      ULONGEST len = TYPE_LENGTH (type);
X
>  
>        if (sparc64_structure_or_union_p (type)
>  	  || (sparc64_complex_floating_p (type) && len == 32))
> diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c
> index 78ba007..76db368 100644
> --- a/gdb/spu-tdep.c
> +++ b/gdb/spu-tdep.c
> @@ -316,7 +316,7 @@ spu_value_from_register (struct type *type, int regnum,
>  			 struct frame_info *frame)
>  {
>    struct value *value = default_value_from_register (type, regnum, frame);
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    if (regnum < SPU_NUM_GPRS && len < 16)
>      {
> diff --git a/gdb/stack.c b/gdb/stack.c
> index bbd6b7f..54e200d 100644
> --- a/gdb/stack.c
> +++ b/gdb/stack.c
> @@ -354,7 +354,7 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame,
>  
>  	  if (val && entryval && !ui_out_is_mi_like_p (current_uiout))
>  	    {
> -	      unsigned len = TYPE_LENGTH (value_type (val));
> +	      ULONGEST len = TYPE_LENGTH (value_type (val));
>  
>  	      if (!value_optimized_out (val) && value_lazy (val))
>  		value_fetch_lazy (val);
> @@ -373,7 +373,7 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame,
>  
>  		  TRY_CATCH (except, RETURN_MASK_ERROR)
>  		    {
> -		      unsigned len_deref;
> +		      ULONGEST len_deref;
>  
>  		      val_deref = coerce_ref (val);
>  		      if (value_lazy (val_deref))
> @@ -532,8 +532,8 @@ print_frame_args (struct symbol *func, struct frame_info *frame,
>  	    case LOC_ARG:
>  	    case LOC_REF_ARG:
>  	      {
> -		long current_offset = SYMBOL_VALUE (sym);
> -		int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
> +		LONGEST current_offset = SYMBOL_VALUE (sym);
> +		ULONGEST arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
X
>  
>  		/* Compute address of next argument by adding the size of
>  		   this argument and rounding to an int boundary.  */
> diff --git a/gdb/symfile-mem.c b/gdb/symfile-mem.c
> index 91125e1..a3c15d0 100644
> --- a/gdb/symfile-mem.c
> +++ b/gdb/symfile-mem.c
> @@ -55,6 +55,11 @@
>  #include "auxv.h"
>  #include "elf/common.h"
>  
> +static int symfile_target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
> +				       int len)
> +{
> +	return target_read_memory (memaddr, myaddr, len);
> +}

Formatting should be (see also tab -> 2 spaces):

static int
symfile_target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
{
  return target_read_memory (memaddr, myaddr, len);
}

But I proposed to rather target_read_memory use size_t and we should then
proposed to bfd/ that it also uses size_t for bfd_elf_bfd_from_remote_memory.


>  
>  /* Read inferior memory at ADDR to find the header of a loaded object file
>     and read its in-core symbols out of inferior memory.  TEMPL is a bfd
> @@ -77,7 +82,7 @@ symbol_file_add_from_memory (struct bfd *templ, CORE_ADDR addr, char *name,
>      error (_("add-symbol-file-from-memory not supported for this target"));
>  
>    nbfd = bfd_elf_bfd_from_remote_memory (templ, addr, &loadbase,
> -					 target_read_memory);
> +					 symfile_target_read_memory);

This would not need to be changed afterwards.


>    if (nbfd == NULL)
>      error (_("Failed to read a valid object file image from memory."));
>  
> diff --git a/gdb/symmisc.c b/gdb/symmisc.c
> index b0ab29b..d5fdd92 100644
> --- a/gdb/symmisc.c
> +++ b/gdb/symmisc.c
> @@ -516,11 +516,11 @@ print_symbol (void *args)
>  
>  	case LOC_CONST_BYTES:
>  	  {
> -	    unsigned i;
> +	    ULONGEST i;
>  	    struct type *type = check_typedef (SYMBOL_TYPE (symbol));
>  
> -	    fprintf_filtered (outfile, "const %u hex bytes:",
> -			      TYPE_LENGTH (type));
> +	    fprintf_filtered (outfile, "const %s hex bytes:",
> +			      pulongest (TYPE_LENGTH (type)));
>  	    for (i = 0; i < TYPE_LENGTH (type); i++)
>  	      fprintf_filtered (outfile, " %02x",
>  				(unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
> diff --git a/gdb/target.c b/gdb/target.c
> index cffea2c..bc7c238 100644
> --- a/gdb/target.c
> +++ b/gdb/target.c
> @@ -52,7 +52,7 @@ static void default_terminal_info (char *, int);
>  static int default_watchpoint_addr_within_range (struct target_ops *,
>  						 CORE_ADDR, CORE_ADDR, int);
>  
> -static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
> +static int default_region_ok_for_hw_watchpoint (CORE_ADDR, LONGEST);
>  
>  static void tcomplain (void) ATTRIBUTE_NORETURN;
>  
> @@ -128,7 +128,7 @@ static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
>  static int debug_to_watchpoint_addr_within_range (struct target_ops *,
>  						  CORE_ADDR, CORE_ADDR, int);
>  
> -static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
> +static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, LONGEST);
>  
>  static int debug_to_can_accel_watchpoint_condition (CORE_ADDR, int, int,
>  						    struct expression *);
> @@ -1757,7 +1757,7 @@ target_xfer_partial (struct target_ops *ops,
>     it makes no progress, and then return how much was transferred).  */
>  
>  int
> -target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
> +target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, LONGEST len)
>  {
>    /* Dispatch to the topmost target, not the flattened current_target.
>       Memory accesses check target->to_has_(all_)memory, and the
> @@ -1773,7 +1773,7 @@ target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
>     the target's stack.  This may trigger different cache behavior.  */
>  
>  int
> -target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
> +target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, LONGEST len)

It may be OK for this patch but a nice 2nd patch cleanup would be to use
size_t.


>  {
>    /* Dispatch to the topmost target, not the flattened current_target.
>       Memory accesses check target->to_has_(all_)memory, and the
> @@ -1792,7 +1792,7 @@ target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
>     Callers that can deal with partial writes should call target_write.  */
>  
>  int
> -target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
> +target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, LONGEST len)

Likewise.

>  {
>    /* Dispatch to the topmost target, not the flattened current_target.
>       Memory accesses check target->to_has_(all_)memory, and the
> @@ -1811,7 +1811,8 @@ target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
>     should call target_write.  */
>  
>  int
> -target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
> +target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
> +			 LONGEST len)

Likewise.

>  {
>    /* Dispatch to the topmost target, not the flattened current_target.
>       Memory accesses check target->to_has_(all_)memory, and the
> @@ -3543,7 +3544,7 @@ target_fileio_read_stralloc (const char *filename)
>  
>  
>  static int
> -default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
> +default_region_ok_for_hw_watchpoint (CORE_ADDR addr, LONGEST len)
>  {
>    return (len <= gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT);
>  }
> @@ -4217,7 +4218,7 @@ debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
>  }
>  
>  static int
> -debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
> +debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, LONGEST len)
>  {
>    CORE_ADDR retval;
>  
> diff --git a/gdb/target.h b/gdb/target.h
> index 50a0ea6..a76f785 100644
> --- a/gdb/target.h
> +++ b/gdb/target.h
> @@ -478,7 +478,7 @@ struct target_ops
>  
>      /* Documentation of this routine is provided with the corresponding
>         target_* macro.  */
> -    int (*to_region_ok_for_hw_watchpoint) (CORE_ADDR, int);
> +    int (*to_region_ok_for_hw_watchpoint) (CORE_ADDR, LONGEST);
>  
>      int (*to_can_accel_watchpoint_condition) (CORE_ADDR, int, int,
>  					      struct expression *);
> @@ -996,15 +996,17 @@ extern void target_dcache_invalidate (void);
>  
>  extern int target_read_string (CORE_ADDR, char **, int, int *);
>  
> -extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
> +extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
> +			       LONGEST len);
>  
> -extern int target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
> +extern int target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr,
> +			      LONGEST len);
>  
>  extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
> -				int len);
> +				LONGEST len);
>  
>  extern int target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
> -				    int len);
> +				    LONGEST len);
>  
>  /* Fetches the target's memory map.  If one is found it is sorted
>     and returned, after some consistency checking.  Otherwise, NULL
> diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
> index 6e47a0a..42af6bc 100644
> --- a/gdb/tracepoint.c
> +++ b/gdb/tracepoint.c
> @@ -967,7 +967,7 @@ collect_symbol (struct collection_list *collect,
>  		long frame_regno, long frame_offset,
>  		CORE_ADDR scope)
>  {
> -  unsigned long len;
> +  ULONGEST len;
>    unsigned int reg;
>    bfd_signed_vma offset;
>    int treat_as_expr = 0;
> @@ -1448,7 +1448,8 @@ encode_actions_1 (struct command_line *action,
>  		}
>  	      else
>  		{
> -		  unsigned long addr, len;
> +		  CORE_ADDR addr;
> +		  ULONGEST len;
>  		  struct cleanup *old_chain = NULL;
>  		  struct cleanup *old_chain1 = NULL;
>  
> @@ -2613,7 +2614,8 @@ scope_info (char *args, int from_tty)
>    const char *symname;
>    char *save_args = args;
>    struct dict_iterator iter;
> -  int j, count = 0;
> +  int count = 0;
> +  ULONGEST j;
X
>    struct gdbarch *gdbarch;
>    int regno;
>  
> @@ -2743,8 +2745,10 @@ scope_info (char *args, int from_tty)
>  	      break;
>  	    }
>  	  if (SYMBOL_TYPE (sym))
> -	    printf_filtered (", length %d.\n",
> -			     TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
> +	    {
> +	      ULONGEST len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));

Missing empty line after declarations.

> +	      printf_filtered (", length %s.\n", pulongest (len));
> +	    }
>  	}
>        if (BLOCK_FUNCTION (block))
>  	break;
> diff --git a/gdb/typeprint.c b/gdb/typeprint.c
> index c25e705..4bbf8a7 100644
> --- a/gdb/typeprint.c
> +++ b/gdb/typeprint.c
> @@ -118,7 +118,7 @@ whatis_exp (char *exp, int show)
>    struct type *real_type = NULL;
>    struct type *type;
>    int full = 0;
> -  int top = -1;
> +  LONGEST top = -1;
>    int using_enc = 0;
>    struct value_print_options opts;
>  
> diff --git a/gdb/v850-tdep.c b/gdb/v850-tdep.c
> index 240a154..8cbf3b3 100644
> --- a/gdb/v850-tdep.c
> +++ b/gdb/v850-tdep.c
> @@ -810,7 +810,7 @@ v850_push_dummy_call (struct gdbarch *gdbarch,
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    int argreg;
>    int argnum;
> -  int len = 0;
> +  ULONGEST len = 0;
X
>    int stack_offset;
>  
>    /* The offset onto the stack at which we will start copying parameters
> @@ -891,7 +891,7 @@ v850_extract_return_value (struct type *type, struct regcache *regcache,
>  {
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
> -  int len = TYPE_LENGTH (type);
> +  LONGEST len = TYPE_LENGTH (type);
>  
>    if (len <= v850_reg_size)
>      {
> @@ -918,7 +918,7 @@ v850_store_return_value (struct type *type, struct regcache *regcache,
>  {
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>  
>    if (len <= v850_reg_size)
>        regcache_cooked_write_unsigned
> diff --git a/gdb/valarith.c b/gdb/valarith.c
> index a17c91a..16e760d 100644
> --- a/gdb/valarith.c
> +++ b/gdb/valarith.c
> @@ -196,8 +196,8 @@ value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound)
>  {
>    struct type *array_type = check_typedef (value_type (array));
>    struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
> -  unsigned int elt_size = TYPE_LENGTH (elt_type);
> -  unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
> +  ULONGEST elt_size = TYPE_LENGTH (elt_type);
> +  ULONGEST elt_offs = elt_size * (index - lowerbound);
>    struct value *v;
>  
>    if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
> @@ -1474,7 +1474,7 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
>  int
>  value_logical_not (struct value *arg1)
>  {
> -  int len;
> +  LONGEST len;
>    const gdb_byte *p;
>    struct type *type1;
>  
> @@ -1505,8 +1505,8 @@ value_logical_not (struct value *arg1)
>  static int
>  value_strcmp (struct value *arg1, struct value *arg2)
>  {
> -  int len1 = TYPE_LENGTH (value_type (arg1));
> -  int len2 = TYPE_LENGTH (value_type (arg2));
> +  LONGEST len1 = TYPE_LENGTH (value_type (arg1));
> +  LONGEST len2 = TYPE_LENGTH (value_type (arg2));
>    const gdb_byte *s1 = value_contents (arg1);
>    const gdb_byte *s2 = value_contents (arg2);
>    int i, len = len1 < len2 ? len1 : len2;
> diff --git a/gdb/valops.c b/gdb/valops.c
> index ee450e3..5018864 100644
> --- a/gdb/valops.c
> +++ b/gdb/valops.c
> @@ -53,11 +53,11 @@ static int typecmp (int staticp, int varargs, int nargs,
>  		    struct field t1[], struct value *t2[]);
>  
>  static struct value *search_struct_field (const char *, struct value *, 
> -					  int, struct type *, int);
> +					  LONGEST, struct type *, int);
>  
>  static struct value *search_struct_method (const char *, struct value **,
>  					   struct value **,
> -					   int, int *, struct type *);
> +					   LONGEST, int *, struct type *);
>  
>  static int find_oload_champ_namespace (struct value **, int,
>  				       const char *, const char *,
> @@ -85,7 +85,7 @@ oload_classification classify_oload_match (struct badness_vector *,
>  					   int, int);
>  
>  static struct value *value_struct_elt_for_reference (struct type *,
> -						     int, struct type *,
> +						     LONGEST, struct type *,
>  						     char *,
>  						     struct type *,
>  						     int, enum noside);
> @@ -102,8 +102,8 @@ static CORE_ADDR allocate_space_in_inferior (int);
>  static struct value *cast_into_complex (struct type *, struct value *);
>  
>  static struct fn_field *find_method_list (struct value **, const char *,
> -					  int, struct type *, int *,
> -					  struct type **, int *);
> +					  LONGEST, struct type *, int *,
> +					  struct type **, LONGEST *);
>  
>  void _initialize_valops (void);
>  
> @@ -188,14 +188,14 @@ find_function_in_inferior (const char *name, struct objfile **objf_p)
>     space.  */
>  
>  struct value *
> -value_allocate_space_in_inferior (int len)
> +value_allocate_space_in_inferior (ULONGEST len)
X
>  {
>    struct objfile *objf;
>    struct value *val = find_function_in_inferior ("malloc", &objf);
>    struct gdbarch *gdbarch = get_objfile_arch (objf);
>    struct value *blocklen;
>  
> -  blocklen = value_from_longest (builtin_type (gdbarch)->builtin_int, len);
> +  blocklen = value_from_ulongest (builtin_type (gdbarch)->builtin_int, len);

This would not be changed then.

>    val = call_function_by_hand (val, 1, &blocklen);
>    if (value_logical_not (val))
>      {
> @@ -261,7 +261,8 @@ value_cast_structs (struct type *type, struct value *v2)
>    if (TYPE_NAME (t2) != NULL)
>      {
>        /* Try downcasting using the run-time type of the value.  */
> -      int full, top, using_enc;
> +      int full, using_enc;
> +      LONGEST top;
>        struct type *real_type;
>  
>        real_type = value_rtti_type (v2, &full, &top, &using_enc);
> @@ -396,12 +397,12 @@ value_cast (struct type *type, struct value *arg2)
>    if (code1 == TYPE_CODE_ARRAY)
>      {
>        struct type *element_type = TYPE_TARGET_TYPE (type);
> -      unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
> +      ULONGEST element_length = TYPE_LENGTH (check_typedef (element_type));
>  
>        if (element_length > 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
>  	{
>  	  struct type *range_type = TYPE_INDEX_TYPE (type);
> -	  int val_length = TYPE_LENGTH (type2);
> +	  ULONGEST val_length = TYPE_LENGTH (type2);
X
>  	  LONGEST low_bound, high_bound, new_length;
>  
>  	  if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
> @@ -651,7 +652,7 @@ value_reinterpret_cast (struct type *type, struct value *arg)
>  static int
>  dynamic_cast_check_1 (struct type *desired_type,
>  		      const gdb_byte *valaddr,
> -		      int embedded_offset,
> +		      LONGEST embedded_offset,
>  		      CORE_ADDR address,
>  		      struct value *val,
>  		      struct type *search_type,
> @@ -663,8 +664,8 @@ dynamic_cast_check_1 (struct type *desired_type,
>  
>    for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
>      {
> -      int offset = baseclass_offset (search_type, i, valaddr, embedded_offset,
> -				     address, val);
> +      LONGEST offset = baseclass_offset (search_type, i, valaddr,
> +					 embedded_offset, address, val);
>  
>        if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
>  	{
> @@ -698,7 +699,7 @@ dynamic_cast_check_1 (struct type *desired_type,
>  static int
>  dynamic_cast_check_2 (struct type *desired_type,
>  		      const gdb_byte *valaddr,
> -		      int embedded_offset,
> +		      LONGEST embedded_offset,
>  		      CORE_ADDR address,
>  		      struct value *val,
>  		      struct type *search_type,
> @@ -708,7 +709,7 @@ dynamic_cast_check_2 (struct type *desired_type,
>  
>    for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
>      {
> -      int offset;
> +      LONGEST offset;
>  
>        if (! BASETYPE_VIA_PUBLIC (search_type, i))
>  	continue;
> @@ -739,7 +740,8 @@ dynamic_cast_check_2 (struct type *desired_type,
>  struct value *
>  value_dynamic_cast (struct type *type, struct value *arg)
>  {
> -  int full, top, using_enc;
> +  int full, using_enc;
> +  LONGEST top;
>    struct type *resolved_type = check_typedef (type);
>    struct type *arg_type = check_typedef (value_type (arg));
>    struct type *class_type, *rtti_type;
> @@ -990,7 +992,7 @@ value_fetch_lazy (struct value *val)
>        struct value *parent = value_parent (val);
>        LONGEST offset = value_offset (val);
>        LONGEST num;
> -      int length = TYPE_LENGTH (type);
> +      ULONGEST length = TYPE_LENGTH (type);
X
>  
>        if (!value_bits_valid (val,
>  			     TARGET_CHAR_BIT * offset + value_bitpos (val),
> @@ -1012,7 +1014,8 @@ value_fetch_lazy (struct value *val)
>    else if (VALUE_LVAL (val) == lval_memory)
>      {
>        CORE_ADDR addr = value_address (val);
> -      int length = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
> +      struct type *enclosing_type = value_enclosing_type (val);
> +      ULONGEST length = TYPE_LENGTH (check_typedef (enclosing_type));
X
>  
>        if (length)
>  	read_value_memory (val, 0, value_stack (val),
> @@ -1123,7 +1126,7 @@ value_fetch_lazy (struct value *val)
>  void
>  read_value_memory (struct value *val, int embedded_offset,
>  		   int stack, CORE_ADDR memaddr,
> -		   gdb_byte *buffer, size_t length)
> +		   gdb_byte *buffer, ULONGEST length)

This should not be changed, or it should be reverted in a 2nd cleanup patch.
size_t is perfect for in-memory buffer.


>  {
>    if (length)
>      {
> @@ -1256,7 +1259,7 @@ value_assign (struct value *toval, struct value *fromval)
>        {
>  	const gdb_byte *dest_buffer;
>  	CORE_ADDR changed_addr;
> -	int changed_len;
> +	ULONGEST changed_len;
X
>          gdb_byte buffer[sizeof (LONGEST)];
>  
>  	if (value_bitsize (toval))
> @@ -1329,7 +1332,7 @@ value_assign (struct value *toval, struct value *fromval)
>  	    if (value_bitsize (toval))
>  	      {
>  		struct value *parent = value_parent (toval);
> -		int offset = value_offset (parent) + value_offset (toval);
> +		LONGEST offset = value_offset (parent) + value_offset (toval);
>  		int changed_len;
>  		gdb_byte buffer[sizeof (LONGEST)];
>  		int optim, unavail;
> @@ -1794,7 +1797,7 @@ value_array (int lowbound, int highbound, struct value **elemvec)
>  {
>    int nelem;
>    int idx;
> -  unsigned int typelength;
> +  ULONGEST typelength;
>    struct value *val;
>    struct type *arraytype;
>  
> @@ -1985,7 +1988,7 @@ typecmp (int staticp, int varargs, int nargs,
>     fields, look for a baseclass named NAME.  */
>  
>  static struct value *
> -search_struct_field (const char *name, struct value *arg1, int offset,
> +search_struct_field (const char *name, struct value *arg1, LONGEST offset,
>  		     struct type *type, int looking_for_baseclass)
>  {
>    int i;
> @@ -2043,7 +2046,7 @@ search_struct_field (const char *name, struct value *arg1, int offset,
>  		   <variant field>.  */
>  
>  		struct value *v;
> -		int new_offset = offset;
> +		LONGEST new_offset = offset;
>  
>  		/* This is pretty gross.  In G++, the offset in an
>  		   anonymous union is relative to the beginning of the
> @@ -2080,7 +2083,7 @@ search_struct_field (const char *name, struct value *arg1, int offset,
>  
>        if (BASETYPE_VIA_VIRTUAL (type, i))
>  	{
> -	  int boffset;
> +	  LONGEST boffset;
>  	  struct value *v2;
>  
>  	  boffset = baseclass_offset (type, i,
> @@ -2144,7 +2147,7 @@ search_struct_field (const char *name, struct value *arg1, int offset,
>  
>  static struct value *
>  search_struct_method (const char *name, struct value **arg1p,
> -		      struct value **args, int offset,
> +		      struct value **args, LONGEST offset,
>  		      int *static_memfuncp, struct type *type)
>  {
>    int i;
> @@ -2208,9 +2211,9 @@ search_struct_method (const char *name, struct value **arg1p,
>  
>    for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
>      {
> -      int base_offset;
> +      LONGEST base_offset;
>        int skip = 0;
> -      int this_offset;
> +      LONGEST this_offset;
>  
>        if (BASETYPE_VIA_VIRTUAL (type, i))
>  	{
> @@ -2386,8 +2389,8 @@ value_struct_elt (struct value **argp, struct value **args,
>  
>  static struct fn_field *
>  find_method_list (struct value **argp, const char *method,
> -		  int offset, struct type *type, int *num_fns,
> -		  struct type **basetype, int *boffset)
> +		  LONGEST offset, struct type *type, int *num_fns,
> +		  struct type **basetype, LONGEST *boffset)
>  {
>    int i;
>    struct fn_field *f;
> @@ -2420,7 +2423,7 @@ find_method_list (struct value **argp, const char *method,
>    /* Not found in object, check in base subobjects.  */
>    for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
>      {
> -      int base_offset;
> +      LONGEST base_offset;
>  
>        if (BASETYPE_VIA_VIRTUAL (type, i))
>  	{
> @@ -2456,7 +2459,7 @@ find_method_list (struct value **argp, const char *method,
>  struct fn_field *
>  value_find_oload_method_list (struct value **argp, const char *method,
>  			      int offset, int *num_fns, 
> -			      struct type **basetype, int *boffset)
> +			      struct type **basetype, LONGEST *boffset)
>  {
>    struct type *t;
>  
> @@ -2548,7 +2551,7 @@ find_overload_match (struct value **args, int nargs,
>    /* Number of overloaded instances being considered.  */
>    int num_fns = 0;
>    struct type *basetype = NULL;
> -  int boffset;
> +  LONGEST boffset;
>  
>    struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL);
>  
> @@ -3255,7 +3258,7 @@ compare_parameters (struct type *t1, struct type *t2, int skip_artificial)
>     the form "DOMAIN::NAME".  */
>  
>  static struct value *
> -value_struct_elt_for_reference (struct type *domain, int offset,
> +value_struct_elt_for_reference (struct type *domain, LONGEST offset,
>  				struct type *curtype, char *name,
>  				struct type *intype, 
>  				int want_address,
> @@ -3292,7 +3295,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
>  	  if (want_address)
>  	    return value_from_longest
>  	      (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
> -	       offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
> +	       offset + (TYPE_FIELD_BITPOS (t, i) >> 3));
>  	  else if (noside == EVAL_AVOID_SIDE_EFFECTS)
>  	    return allocate_value (TYPE_FIELD_TYPE (t, i));
>  	  else
> @@ -3435,7 +3438,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
>    for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
>      {
>        struct value *v;
> -      int base_offset;
> +      LONGEST base_offset;
>  
>        if (BASETYPE_VIA_VIRTUAL (t, i))
>  	base_offset = 0;
> @@ -3525,7 +3528,7 @@ value_maybe_namespace_elt (const struct type *curtype,
>  
>  struct type *
>  value_rtti_indirect_type (struct value *v, int *full, 
> -			  int *top, int *using_enc)
> +			  LONGEST *top, int *using_enc)
>  {
>    struct value *target;
>    struct type *type, *real_type, *target_type;
> @@ -3575,12 +3578,12 @@ value_rtti_indirect_type (struct value *v, int *full,
>  struct value *
>  value_full_object (struct value *argp, 
>  		   struct type *rtype, 
> -		   int xfull, int xtop,
> +		   int xfull, LONGEST xtop,
>  		   int xusing_enc)
>  {
>    struct type *real_type;
>    int full = 0;
> -  int top = -1;
> +  LONGEST top = -1;
>    int using_enc = 0;
>    struct value *new_val;
>  
> diff --git a/gdb/valprint.c b/gdb/valprint.c
> index 25b62bc..f5e168a 100644
> --- a/gdb/valprint.c
> +++ b/gdb/valprint.c
> @@ -253,7 +253,7 @@ scalar_type_p (struct type *type)
>  int
>  valprint_check_validity (struct ui_file *stream,
>  			 struct type *type,
> -			 int embedded_offset,
> +			 LONGEST embedded_offset,
>  			 const struct value *val)
>  {
>    CHECK_TYPEDEF (type);
> @@ -317,7 +317,7 @@ val_print_invalid_address (struct ui_file *stream)
>  
>  void
>  generic_val_print (struct type *type, const gdb_byte *valaddr,
> -		   int embedded_offset, CORE_ADDR address,
> +		   LONGEST embedded_offset, CORE_ADDR address,
>  		   struct ui_file *stream, int recurse,
>  		   const struct value *original_value,
>  		   const struct value_print_options *options,
> @@ -680,7 +680,7 @@ generic_val_print (struct type *type, const gdb_byte *valaddr,
>     RECURSE.  */
>  
>  void
> -val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
> +val_print (struct type *type, const gdb_byte *valaddr, LONGEST embedded_offset,
>  	   CORE_ADDR address, struct ui_file *stream, int recurse,
>  	   const struct value *val,
>  	   const struct value_print_options *options,
> @@ -892,7 +892,7 @@ val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
>  
>  void
>  val_print_scalar_formatted (struct type *type,
> -			    const gdb_byte *valaddr, int embedded_offset,
> +			    const gdb_byte *valaddr, LONGEST embedded_offset,
>  			    const struct value *val,
>  			    const struct value_print_options *options,
>  			    int size,
> @@ -1433,7 +1433,7 @@ print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,
>  
>  void
>  print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
> -		 unsigned len, enum bfd_endian byte_order)
> +		 ULONGEST len, enum bfd_endian byte_order)
>  {
>    const gdb_byte *p;
>  
> @@ -1550,7 +1550,7 @@ maybe_print_array_index (struct type *index_type, LONGEST index,
>  
>  void
>  val_print_array_elements (struct type *type,
> -			  const gdb_byte *valaddr, int embedded_offset,
> +			  const gdb_byte *valaddr, LONGEST embedded_offset,
>  			  CORE_ADDR address, struct ui_file *stream,
>  			  int recurse,
>  			  const struct value *val,
> @@ -1558,9 +1558,9 @@ val_print_array_elements (struct type *type,
>  			  unsigned int i)
>  {
>    unsigned int things_printed = 0;
> -  unsigned len;
> +  ULONGEST len;
>    struct type *elttype, *index_type;
> -  unsigned eltlen;
> +  ULONGEST eltlen;
>    /* Position of the array element we are examining to see
>       whether it is repeated.  */
>    unsigned int rep1;
> @@ -2046,8 +2046,8 @@ generic_emit_char (int c, struct type *type, struct ui_file *stream,
>     omitted.  */
>  
>  void
> -generic_printstr (struct ui_file *stream, struct type *type, 
> -		  const gdb_byte *string, unsigned int length, 
> +generic_printstr (struct ui_file *stream, struct type *type,
> +		  const gdb_byte *string, ULONGEST length,
>  		  const char *encoding, int force_ellipses,
>  		  int quote_char, int c_style_terminator,
>  		  const struct value_print_options *options)
> diff --git a/gdb/valprint.h b/gdb/valprint.h
> index 56c0c92..2841929 100644
> --- a/gdb/valprint.h
> +++ b/gdb/valprint.h
> @@ -113,7 +113,7 @@ extern void maybe_print_array_index (struct type *index_type, LONGEST index,
>                                       struct ui_file *stream,
>  				     const struct value_print_options *);
>  
> -extern void val_print_array_elements (struct type *, const gdb_byte *, int,
> +extern void val_print_array_elements (struct type *, const gdb_byte *, LONGEST,
>  				      CORE_ADDR, struct ui_file *, int,
>  				      const struct value *,
>  				      const struct value_print_options *,
> @@ -127,7 +127,7 @@ extern void val_print_type_code_flags (struct type *type,
>  				       struct ui_file *stream);
>  
>  extern void val_print_scalar_formatted (struct type *,
> -					const gdb_byte *, int,
> +					const gdb_byte *, LONGEST,
>  					const struct value *,
>  					const struct value_print_options *,
>  					int,
> @@ -143,7 +143,7 @@ extern void print_decimal_chars (struct ui_file *, const gdb_byte *,
>  				 unsigned int, enum bfd_endian);
>  
>  extern void print_hex_chars (struct ui_file *, const gdb_byte *,
> -			     unsigned int, enum bfd_endian);
> +			     ULONGEST, enum bfd_endian);
>  
>  extern void print_char_chars (struct ui_file *, struct type *,
>  			      const gdb_byte *, unsigned int, enum bfd_endian);
> @@ -187,7 +187,7 @@ struct generic_val_print_decorations
>  
>  
>  extern void generic_val_print (struct type *type, const gdb_byte *valaddr,
> -			       int embedded_offset, CORE_ADDR address,
> +			       LONGEST embedded_offset, CORE_ADDR address,
>  			       struct ui_file *stream, int recurse,
>  			       const struct value *original_value,
>  			       const struct value_print_options *options,
> @@ -196,8 +196,8 @@ extern void generic_val_print (struct type *type, const gdb_byte *valaddr,
>  extern void generic_emit_char (int c, struct type *type, struct ui_file *stream,
>  			       int quoter, const char *encoding);
>  
> -extern void generic_printstr (struct ui_file *stream, struct type *type, 
> -			      const gdb_byte *string, unsigned int length, 
> +extern void generic_printstr (struct ui_file *stream, struct type *type,
> +			      const gdb_byte *string, ULONGEST length,
>  			      const char *encoding, int force_ellipses,
>  			      int quote_char, int c_style_terminator,
>  			      const struct value_print_options *options);
> diff --git a/gdb/value.c b/gdb/value.c
> index d498289..30a4a42 100644
> --- a/gdb/value.c
> +++ b/gdb/value.c
> @@ -67,10 +67,10 @@ struct internal_function
>  struct range
>  {
>    /* Lowest offset in the range.  */
> -  int offset;
> +  LONGEST offset;
>  
>    /* Length of the range.  */
> -  int length;
> +  ULONGEST length;
X
>  };
>  
>  typedef struct range range_s;
> @@ -81,8 +81,8 @@ DEF_VEC_O(range_s);
>     [offset2, offset2+len2) overlap.  */
>  
>  static int
> -ranges_overlap (int offset1, int len1,
> -		int offset2, int len2)
> +ranges_overlap (LONGEST offset1, ULONGEST len1,
X
> +		LONGEST offset2, ULONGEST len2)
X
>  {
>    ULONGEST h, l;
>  
> @@ -106,7 +106,7 @@ range_lessthan (const range_s *r1, const range_s *r2)
>     OFFSET+LENGTH).  */
>  
>  static int
> -ranges_contain (VEC(range_s) *ranges, int offset, int length)
> +ranges_contain (VEC(range_s) *ranges, LONGEST offset, ULONGEST length)
X
>  {
>    range_s what;
>    int i;
> @@ -239,7 +239,7 @@ struct value
>       lval == lval_register, this is a further offset from
>       location.address within the registers structure.  Note also the
>       member embedded_offset below.  */
> -  int offset;
> +  LONGEST offset;
>  
>    /* Only used for bitfields; number of bits contained in them.  */
>    int bitsize;
> @@ -309,8 +309,8 @@ struct value
>       `type', and `embedded_offset' is zero, so everything works
>       normally.  */
>    struct type *enclosing_type;
> -  int embedded_offset;
> -  int pointed_to_offset;
> +  LONGEST embedded_offset;
> +  LONGEST pointed_to_offset;
>  
>    /* Values are stored in a chain, so that they can be deleted easily
>       over calls to the inferior.  Values assigned to internal
> @@ -332,7 +332,8 @@ struct value
>  };
>  
>  int
> -value_bytes_available (const struct value *value, int offset, int length)
> +value_bytes_available (const struct value *value, LONGEST offset,
> +		       ULONGEST length)
X
>  {
>    gdb_assert (!value->lazy);
>  
> @@ -353,7 +354,8 @@ value_entirely_available (struct value *value)
>  }
>  
>  void
> -mark_value_bytes_unavailable (struct value *value, int offset, int length)
> +mark_value_bytes_unavailable (struct value *value, LONGEST offset,
> +			      ULONGEST length)
X
>  {
>    range_s newr;
>    int i;
> @@ -524,7 +526,7 @@ mark_value_bytes_unavailable (struct value *value, int offset, int length)
>  
>  static int
>  find_first_range_overlap (VEC(range_s) *ranges, int pos,
> -			  int offset, int length)
> +			  LONGEST offset, ULONGEST length)
X
>  {
>    range_s *r;
>    int i;
> @@ -537,9 +539,9 @@ find_first_range_overlap (VEC(range_s) *ranges, int pos,
>  }
>  
>  int
> -value_available_contents_eq (const struct value *val1, int offset1,
> -			     const struct value *val2, int offset2,
> -			     int length)
> +value_available_contents_eq (const struct value *val1, LONGEST offset1,
> +			     const struct value *val2, LONGEST offset2,
> +			     ULONGEST length)
X
>  {
>    int idx1 = 0, idx2 = 0;
>  
> @@ -767,13 +769,13 @@ deprecated_set_value_type (struct value *value, struct type *type)
>    value->type = type;
>  }
>  
> -int
> +LONGEST
>  value_offset (const struct value *value)
>  {
>    return value->offset;
>  }
>  void
> -set_value_offset (struct value *value, int offset)
> +set_value_offset (struct value *value, LONGEST offset)
>  {
>    value->offset = offset;
>  }
> @@ -924,8 +926,9 @@ value_contents_all (struct value *value)
>     DST_OFFSET+LENGTH) range are wholly available.  */
>  
>  void
> -value_contents_copy_raw (struct value *dst, int dst_offset,
> -			 struct value *src, int src_offset, int length)
> +value_contents_copy_raw (struct value *dst, LONGEST dst_offset,
> +			 struct value *src, LONGEST src_offset,
> +			 ULONGEST length)
X
>  {
>    range_s *r;
>    int i;
> @@ -973,8 +976,8 @@ value_contents_copy_raw (struct value *dst, int dst_offset,
>     DST_OFFSET+LENGTH) range are wholly available.  */
>  
>  void
> -value_contents_copy (struct value *dst, int dst_offset,
> -		     struct value *src, int src_offset, int length)
> +value_contents_copy (struct value *dst, LONGEST dst_offset,
> +		     struct value *src, LONGEST src_offset, ULONGEST length)
X
>  {
>    require_not_optimized_out (src);
>  
> @@ -1034,7 +1037,7 @@ value_contents_equal (struct value *val1, struct value *val2)
>  {
>    struct type *type1;
>    struct type *type2;
> -  int len;
> +  ULONGEST len;
X
>  
>    type1 = check_typedef (value_type (val1));
>    type2 = check_typedef (value_type (val2));
> @@ -1069,7 +1072,7 @@ value_entirely_optimized_out (const struct value *value)
>  }
>  
>  int
> -value_bits_valid (const struct value *value, int offset, int length)
> +value_bits_valid (const struct value *value, LONGEST offset, ULONGEST length)
X
>  {
>    if (!value->optimized_out)
>      return 1;
> @@ -1082,7 +1085,7 @@ value_bits_valid (const struct value *value, int offset, int length)
>  
>  int
>  value_bits_synthetic_pointer (const struct value *value,
> -			      int offset, int length)
> +			      LONGEST offset, ULONGEST length)
X
>  {
>    if (value->lval != lval_computed
>        || !value->location.computed.funcs->check_synthetic_pointer)
> @@ -1092,26 +1095,26 @@ value_bits_synthetic_pointer (const struct value *value,
>  								  length);
>  }
>  
> -int
> +LONGEST
>  value_embedded_offset (struct value *value)
>  {
>    return value->embedded_offset;
>  }
>  
>  void
> -set_value_embedded_offset (struct value *value, int val)
> +set_value_embedded_offset (struct value *value, LONGEST val)
>  {
>    value->embedded_offset = val;
>  }
>  
> -int
> +LONGEST
>  value_pointed_to_offset (struct value *value)
>  {
>    return value->pointed_to_offset;
>  }
>  
>  void
> -set_value_pointed_to_offset (struct value *value, int val)
> +set_value_pointed_to_offset (struct value *value, LONGEST val)
>  {
>    value->pointed_to_offset = val;
>  }
> @@ -1914,7 +1917,7 @@ get_internalvar_function (struct internalvar *var,
>  }
>  
>  void
> -set_internalvar_component (struct internalvar *var, int offset, int bitpos,
> +set_internalvar_component (struct internalvar *var, LONGEST offset, int bitpos,
>  			   int bitsize, struct value *newval)
>  {
>    gdb_byte *addr;
> @@ -2583,7 +2586,7 @@ set_value_enclosing_type (struct value *val, struct type *new_encl_type)
>     FIELDNO says which field.  */
>  
>  struct value *
> -value_primitive_field (struct value *arg1, int offset,
> +value_primitive_field (struct value *arg1, LONGEST offset,
>  		       int fieldno, struct type *arg_type)
>  {
>    struct value *v;
> @@ -2613,8 +2616,8 @@ value_primitive_field (struct value *arg1, int offset,
>  	 bit.  Assume that the address, offset, and embedded offset
>  	 are sufficiently aligned.  */
>  
> -      int bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno);
> -      int container_bitsize = TYPE_LENGTH (type) * 8;
> +      LONGEST bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno);
> +      ULONGEST container_bitsize = TYPE_LENGTH (type) * 8;
X
>  
>        v = allocate_value_lazy (type);
>        v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno);
> @@ -2636,7 +2639,7 @@ value_primitive_field (struct value *arg1, int offset,
>        /* This field is actually a base subobject, so preserve the
>  	 entire object's contents for later references to virtual
>  	 bases, etc.  */
> -      int boffset;
> +      LONGEST boffset;
>  
>        /* Lazy register values with offsets are not supported.  */
>        if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))
> @@ -2713,7 +2716,7 @@ value_field (struct value *arg1, int fieldno)
>  struct value *
>  value_fn_field (struct value **arg1p, struct fn_field *f,
>  		int j, struct type *type,
> -		int offset)
> +		LONGEST offset)
>  {
>    struct value *v;
>    struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
> @@ -2773,8 +2776,8 @@ value_fn_field (struct value **arg1p, struct fn_field *f,
>  
>  static int
>  unpack_value_bits_as_long_1 (struct type *field_type, const gdb_byte *valaddr,
> -			     int embedded_offset, int bitpos, int bitsize,
> -			     const struct value *original_value,
> +			     LONGEST embedded_offset, LONGEST bitpos,
> +			     int bitsize, const struct value *original_value,
>  			     LONGEST *result)
>  {
>    enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (field_type));
> @@ -2782,7 +2785,7 @@ unpack_value_bits_as_long_1 (struct type *field_type, const gdb_byte *valaddr,
>    ULONGEST valmask;
>    int lsbcount;
>    int bytes_read;
> -  int read_offset;
> +  LONGEST read_offset;
>  
>    /* Read the minimum number of bytes required; there may not be
>       enough bytes to read an entire ULONGEST.  */
> @@ -2852,7 +2855,7 @@ unpack_value_bits_as_long_1 (struct type *field_type, const gdb_byte *valaddr,
>  
>  int
>  unpack_value_bits_as_long (struct type *field_type, const gdb_byte *valaddr,
> -			   int embedded_offset, int bitpos, int bitsize,
> +			   LONGEST embedded_offset, int bitpos, int bitsize,
>  			   const struct value *original_value,
>  			   LONGEST *result)
>  {
> @@ -2870,10 +2873,10 @@ unpack_value_bits_as_long (struct type *field_type, const gdb_byte *valaddr,
>  
>  static int
>  unpack_value_field_as_long_1 (struct type *type, const gdb_byte *valaddr,
> -			      int embedded_offset, int fieldno,
> +			      LONGEST embedded_offset, int fieldno,
>  			      const struct value *val, LONGEST *result)
>  {
> -  int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
> +  LONGEST bitpos = TYPE_FIELD_BITPOS (type, fieldno);
>    int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
>    struct type *field_type = TYPE_FIELD_TYPE (type, fieldno);
>  
> @@ -2889,7 +2892,7 @@ unpack_value_field_as_long_1 (struct type *type, const gdb_byte *valaddr,
>  
>  int
>  unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
> -			    int embedded_offset, int fieldno,
> +			    LONGEST embedded_offset, int fieldno,
>  			    const struct value *val, LONGEST *result)
>  {
>    gdb_assert (val != NULL);
> @@ -2921,7 +2924,7 @@ unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno)
>  struct value *
>  value_field_bitfield (struct type *type, int fieldno,
>  		      const gdb_byte *valaddr,
> -		      int embedded_offset, const struct value *val)
> +		      LONGEST embedded_offset, const struct value *val)
>  {
>    LONGEST l;
>  
> @@ -2948,12 +2951,12 @@ value_field_bitfield (struct type *type, int fieldno,
>  
>  void
>  modify_field (struct type *type, gdb_byte *addr,
> -	      LONGEST fieldval, int bitpos, int bitsize)
> +	      LONGEST fieldval, LONGEST bitpos, unsigned int bitsize)

WHy to make bitsize unsigned here?

>  {
>    enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
>    ULONGEST oword;
>    ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize);
> -  int bytesize;
> +  ULONGEST bytesize;
X
>  
>    /* Normalize BITPOS.  */
>    addr += bitpos / 8;
> diff --git a/gdb/value.h b/gdb/value.h
> index 76c8e85..f953217 100644
> --- a/gdb/value.h
> +++ b/gdb/value.h
> @@ -82,8 +82,8 @@ extern void set_value_parent (struct value *value, struct value *parent);
>     within the registers structure.  Note also the member
>     embedded_offset below.  */
>  
> -extern int value_offset (const struct value *);
> -extern void set_value_offset (struct value *, int offset);
> +extern LONGEST value_offset (const struct value *);
> +extern void set_value_offset (struct value *, LONGEST offset);
>  
>  /* The comment from "struct value" reads: ``Is it modifiable?  Only
>     relevant if lval != not_lval.''.  Shouldn't the value instead be
> @@ -154,10 +154,10 @@ extern struct type *value_actual_type (struct value *value,
>  				       int resolve_simple_types,
>  				       int *real_type_found);
>  
> -extern int value_pointed_to_offset (struct value *value);
> -extern void set_value_pointed_to_offset (struct value *value, int val);
> -extern int value_embedded_offset (struct value *value);
> -extern void set_value_embedded_offset (struct value *value, int val);
> +extern LONGEST value_pointed_to_offset (struct value *value);
> +extern void set_value_pointed_to_offset (struct value *value, LONGEST val);
> +extern LONGEST value_embedded_offset (struct value *value);
> +extern void set_value_embedded_offset (struct value *value, LONGEST val);
>  
>  /* For lval_computed values, this structure holds functions used to
>     retrieve and set the value (or portions of the value).
> @@ -185,7 +185,8 @@ struct lval_funcs
>    /* Check the validity of some bits in VALUE.  This should return 1
>       if all the bits starting at OFFSET and extending for LENGTH bits
>       are valid, or 0 if any bit is invalid.  */
> -  int (*check_validity) (const struct value *value, int offset, int length);
> +  int (*check_validity) (const struct value *value, LONGEST offset,
> +			 ULONGEST length);
X
>  
>    /* Return 1 if any bit in VALUE is valid, 0 if they are all invalid.  */
>    int (*check_any_valid) (const struct value *value);
> @@ -203,7 +204,7 @@ struct lval_funcs
>    /* If non-NULL, this is used to determine whether the indicated bits
>       of VALUE are a synthetic pointer.  */
>    int (*check_synthetic_pointer) (const struct value *value,
> -				  int offset, int length);
> +				  LONGEST offset, ULONGEST length);
X
>  
>    /* Return a duplicate of VALUE's closure, for use in a new value.
>       This may simply return the same closure, if VALUE's is
> @@ -240,7 +241,7 @@ extern struct value *allocate_computed_value (struct type *type,
>     Otherwise, return 1.  */
>  
>  extern int valprint_check_validity (struct ui_file *stream, struct type *type,
> -				    int embedded_offset,
> +				    LONGEST embedded_offset,
>  				    const struct value *val);
>  
>  extern struct value *allocate_optimized_out_value (struct type *type);
> @@ -411,13 +412,13 @@ extern struct value *coerce_array (struct value *value);
>     bits in the given range are valid, zero if any bit is invalid.  */
>  
>  extern int value_bits_valid (const struct value *value,
> -			     int offset, int length);
> +			     LONGEST offset, ULONGEST length);
X
>  
>  /* Given a value, determine whether the bits starting at OFFSET and
>     extending for LENGTH bits are a synthetic pointer.  */
>  
>  extern int value_bits_synthetic_pointer (const struct value *value,
> -					 int offset, int length);
> +					 LONGEST offset, ULONGEST length);
X
>  
>  /* Given a value, determine whether the contents bytes starting at
>     OFFSET and extending for LENGTH bytes are available.  This returns
> @@ -425,7 +426,7 @@ extern int value_bits_synthetic_pointer (const struct value *value,
>     byte is unavailable.  */
>  
>  extern int value_bytes_available (const struct value *value,
> -				  int offset, int length);
> +				  LONGEST offset, ULONGEST length);
X
>  
>  /* Like value_bytes_available, but return false if any byte in the
>     whole object is unavailable.  */
> @@ -435,7 +436,7 @@ extern int value_entirely_available (struct value *value);
>     LENGTH bytes as unavailable.  */
>  
>  extern void mark_value_bytes_unavailable (struct value *value,
> -					  int offset, int length);
> +					  LONGEST offset, ULONGEST length);
X
>  
>  /* Compare LENGTH bytes of VAL1's contents starting at OFFSET1 with
>     LENGTH bytes of VAL2's contents starting at OFFSET2.
> @@ -445,7 +446,7 @@ extern void mark_value_bytes_unavailable (struct value *value,
>     example, to compare a complete object value with itself, including
>     its enclosing type chunk, you'd do:
>  
> -     int len = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
> +     ULONGEST len = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
X
>       value_available_contents (val, 0, val, 0, len);
>  
>     Returns true iff the set of available contents match.  Unavailable
> @@ -467,9 +468,10 @@ extern void mark_value_bytes_unavailable (struct value *value,
>     value_available_contents_eq(val, 3, val, 4, 4) => 0
>  */
>  
> -extern int value_available_contents_eq (const struct value *val1, int offset1,
> -					const struct value *val2, int offset2,
> -					int length);
> +extern int value_available_contents_eq (const struct value *val1,
> +					LONGEST offset1,
> +					const struct value *val2,
> +					LONGEST offset2, ULONGEST length);
X
>  
>  /* Read LENGTH bytes of memory starting at MEMADDR into BUFFER, which
>     is (or will be copied to) VAL's contents buffer offset by
> @@ -480,7 +482,7 @@ extern int value_available_contents_eq (const struct value *val1, int offset1,
>  
>  extern void read_value_memory (struct value *val, int embedded_offset,
>  			       int stack, CORE_ADDR memaddr,
> -			       gdb_byte *buffer, size_t length);
> +			       gdb_byte *buffer, ULONGEST length);

I think I commented it somewhere, size_t is right, so if you want it here for
split the 2nd cleanup patch should revert it.


>  
>  
>  
> @@ -505,7 +507,7 @@ extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr);
>  
>  extern int unpack_value_bits_as_long (struct type *field_type,
>  				      const gdb_byte *valaddr,
> -				      int embedded_offset, int bitpos,
> +				      LONGEST embedded_offset, int bitpos,
>  				      int bitsize,
>  				      const struct value *original_value,
>  				      LONGEST *result);
> @@ -514,12 +516,12 @@ extern LONGEST unpack_field_as_long (struct type *type,
>  				     const gdb_byte *valaddr,
>  				     int fieldno);
>  extern int unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
> -				int embedded_offset, int fieldno,
> +				LONGEST embedded_offset, int fieldno,
>  				const struct value *val, LONGEST *result);
>  
>  extern struct value *value_field_bitfield (struct type *type, int fieldno,
>  					   const gdb_byte *valaddr,
> -					   int embedded_offset,
> +					   LONGEST embedded_offset,
>  					   const struct value *val);
>  
>  extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num);
> @@ -573,12 +575,12 @@ extern struct value *default_read_var_value (struct symbol *var,
>  extern struct value *allocate_value (struct type *type);
>  extern struct value *allocate_value_lazy (struct type *type);
>  extern void allocate_value_contents (struct value *value);
> -extern void value_contents_copy (struct value *dst, int dst_offset,
> -				 struct value *src, int src_offset,
> -				 int length);
> -extern void value_contents_copy_raw (struct value *dst, int dst_offset,
> -				     struct value *src, int src_offset,
> -				     int length);
> +extern void value_contents_copy (struct value *dst, LONGEST dst_offset,
> +				 struct value *src, LONGEST src_offset,
> +				 ULONGEST length);
X
> +extern void value_contents_copy_raw (struct value *dst, LONGEST dst_offset,
> +				     struct value *src, LONGEST src_offset,
> +				     ULONGEST length);
X
>  
>  extern struct value *allocate_repeat_value (struct type *type, int count);
>  
> @@ -644,7 +646,8 @@ extern struct value *value_static_field (struct type *type, int fieldno);
>  extern struct fn_field *value_find_oload_method_list (struct value **,
>  						      const char *,
>  						      int, int *,
> -						      struct type **, int *);
> +						      struct type **,
> +						      LONGEST *);
>  
>  enum oload_search_type { NON_METHOD, METHOD, BOTH };
>  
> @@ -657,16 +660,16 @@ extern int find_overload_match (struct value **args, int nargs,
>  
>  extern struct value *value_field (struct value *arg1, int fieldno);
>  
> -extern struct value *value_primitive_field (struct value *arg1, int offset,
> +extern struct value *value_primitive_field (struct value *arg1, LONGEST offset,
>  					    int fieldno,
>  					    struct type *arg_type);
>  
>  
> -extern struct type *value_rtti_indirect_type (struct value *, int *, int *,
> +extern struct type *value_rtti_indirect_type (struct value *, int *, LONGEST *,
>  					      int *);
>  
>  extern struct value *value_full_object (struct value *, struct type *, int,
> -					int, int);
> +					LONGEST, int);
>  
>  extern struct value *value_cast_pointers (struct type *, struct value *);
>  
> @@ -756,7 +759,7 @@ extern void set_internalvar_string (struct internalvar *var,
>  extern void clear_internalvar (struct internalvar *var);
>  
>  extern void set_internalvar_component (struct internalvar *var,
> -				       int offset,
> +				       LONGEST offset,
>  				       int bitpos, int bitsize,
>  				       struct value *newvalue);
>  
> @@ -836,7 +839,7 @@ extern struct value *value_x_unop (struct value *arg1, enum exp_opcode op,
>  				   enum noside noside);
>  
>  extern struct value *value_fn_field (struct value **arg1p, struct fn_field *f,
> -				     int j, struct type *type, int offset);
> +				     int j, struct type *type, LONGEST offset);
>  
>  extern int binop_types_user_defined_p (enum exp_opcode op,
>  				       struct type *type1,
> @@ -864,7 +867,8 @@ extern void release_value_or_incref (struct value *val);
>  extern int record_latest_value (struct value *val);
>  
>  extern void modify_field (struct type *type, gdb_byte *addr,
> -			  LONGEST fieldval, int bitpos, int bitsize);
> +			  LONGEST fieldval, LONGEST bitpos,
> +			  unsigned int bitsize);

Why making bitsize unsigned?

>  
>  extern void type_print (struct type *type, const char *varstring,
>  			struct ui_file *stream, int show);
> @@ -894,7 +898,7 @@ extern void value_print_array_elements (struct value *val,
>  extern struct value *value_release_to_mark (struct value *mark);
>  
>  extern void val_print (struct type *type, const gdb_byte *valaddr,
> -		       int embedded_offset, CORE_ADDR address,
> +		       LONGEST embedded_offset, CORE_ADDR address,
>  		       struct ui_file *stream, int recurse,
>  		       const struct value *val,
>  		       const struct value_print_options *options,
> @@ -945,7 +949,7 @@ extern struct value *value_literal_complex (struct value *, struct value *,
>  extern struct value *find_function_in_inferior (const char *,
>  						struct objfile **);
>  
> -extern struct value *value_allocate_space_in_inferior (int);
> +extern struct value *value_allocate_space_in_inferior (ULONGEST);
X
>  
>  extern struct value *value_subscripted_rvalue (struct value *array,
>  					       LONGEST index, int lowerbound);
> diff --git a/gdb/vax-tdep.c b/gdb/vax-tdep.c
> index 0dcca75..378cf05 100644
> --- a/gdb/vax-tdep.c
> +++ b/gdb/vax-tdep.c
> @@ -116,7 +116,7 @@ vax_store_arguments (struct regcache *regcache, int nargs,
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    gdb_byte buf[4];
> -  int count = 0;
> +  ULONGEST count = 0;
X
>    int i;
>  
>    /* We create an argument list on the stack, and make the argument
> @@ -125,7 +125,7 @@ vax_store_arguments (struct regcache *regcache, int nargs,
>    /* Push arguments in reverse order.  */
>    for (i = nargs - 1; i >= 0; i--)
>      {
> -      int len = TYPE_LENGTH (value_enclosing_type (args[i]));
> +      ULONGEST len = TYPE_LENGTH (value_enclosing_type (args[i]));
X
>  
>        sp -= (len + 3) & ~3;
>        count += (len + 3) / 4;
> @@ -208,7 +208,7 @@ vax_return_value (struct gdbarch *gdbarch, struct type *func_type,
>  		  struct type *type, struct regcache *regcache,
>  		  gdb_byte *readbuf, const gdb_byte *writebuf)
>  {
> -  int len = TYPE_LENGTH (type);
> +  ULONGEST len = TYPE_LENGTH (type);
X
>    gdb_byte buf[8];
>  
>    if (TYPE_CODE (type) == TYPE_CODE_STRUCT
> diff --git a/gdb/xstormy16-tdep.c b/gdb/xstormy16-tdep.c
> index cfef755..c77e25d 100644
> --- a/gdb/xstormy16-tdep.c
> +++ b/gdb/xstormy16-tdep.c
> @@ -162,8 +162,9 @@ static void
>  xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
>  				void *valbuf)
>  {
> -  int len = TYPE_LENGTH (type);
> -  int i, regnum = E_1ST_ARG_REGNUM;
> +  ULONGEST len = TYPE_LENGTH (type);
X
> +  ULONGEST i;
X
> +  int regnum = E_1ST_ARG_REGNUM;
>  
>    for (i = 0; i < len; i += xstormy16_reg_size)
>      regcache_raw_read (regcache, regnum++, (char *) valbuf + i);
> @@ -188,8 +189,9 @@ xstormy16_store_return_value (struct type *type, struct regcache *regcache,
>      }
>    else
>      {
> -      int len = TYPE_LENGTH (type);
> -      int i, regnum = E_1ST_ARG_REGNUM;
> +      ULONGEST len = TYPE_LENGTH (type);
X
> +      ULONGEST i;
X
> +      int regnum = E_1ST_ARG_REGNUM;
>  
>        for (i = 0; i < len; i += xstormy16_reg_size)
>          regcache_raw_write (regcache, regnum++, (char *) valbuf + i);
> @@ -235,8 +237,9 @@ xstormy16_push_dummy_call (struct gdbarch *gdbarch,
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    CORE_ADDR stack_dest = sp;
>    int argreg = E_1ST_ARG_REGNUM;
> -  int i, j;
> -  int typelen, slacklen;
> +  int i, slacklen;
> +  LONGEST j;
> +  ULONGEST typelen;
X
>    const gdb_byte *val;
>    char buf[xstormy16_pc_size];
>  
> diff --git a/gdb/xtensa-tdep.c b/gdb/xtensa-tdep.c
> index 78d8888..79308b7 100644
> --- a/gdb/xtensa-tdep.c
> +++ b/gdb/xtensa-tdep.c
> @@ -1581,7 +1581,7 @@ xtensa_extract_return_value (struct type *type,
>  {
>    struct gdbarch *gdbarch = get_regcache_arch (regcache);
>    bfd_byte *valbuf = dst;
> -  int len = TYPE_LENGTH (type);
> +  LONGEST len = TYPE_LENGTH (type);
>    ULONGEST pc, wb;
>    int callsize, areg;
>    int offset = 0;
> @@ -1599,8 +1599,8 @@ xtensa_extract_return_value (struct type *type,
>        /* On Xtensa, we can return up to 4 words (or 2 for call12).  */
>        if (len > (callsize > 8 ? 8 : 16))
>  	internal_error (__FILE__, __LINE__,
> -			_("cannot extract return value of %d bytes long"),
> -			len);
> +			_("cannot extract return value of %s bytes long"),
> +			pulongest (len));

It should be plongest already with your patch.

>  
>        /* Get the register offset of the return
>  	 register (A2) in the caller window.  */
> @@ -1615,7 +1615,8 @@ xtensa_extract_return_value (struct type *type,
>        areg = gdbarch_tdep (gdbarch)->a0_base + C0_ARGS;
>      }
>  
> -  DEBUGINFO ("[xtensa_extract_return_value] areg %d len %d\n", areg, len);
> +  DEBUGINFO ("[xtensa_extract_return_value] areg %d len %s\n", areg,
> +	     pulongest (len));

It should be plongest already with your patch.

>  
>    if (len < 4 && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
>      offset = 4 - len;
> @@ -1640,7 +1641,7 @@ xtensa_store_return_value (struct type *type,
>    unsigned int areg;
>    ULONGEST pc, wb;
>    int callsize;
> -  int len = TYPE_LENGTH (type);
> +  LONGEST len = TYPE_LENGTH (type);
>    int offset = 0;
>  
>    DEBUGTRACE ("xtensa_store_return_value (...)\n");
> @@ -1654,8 +1655,8 @@ xtensa_store_return_value (struct type *type,
>  
>        if (len > (callsize > 8 ? 8 : 16))
>  	internal_error (__FILE__, __LINE__,
> -			_("unimplemented for this length: %d"),
> -			TYPE_LENGTH (type));
> +			_("unimplemented for this length: %s"),
> +			pulongest (TYPE_LENGTH (type)));
>        areg = arreg_number (gdbarch,
>  			   gdbarch_tdep (gdbarch)->a0_base + 2 + callsize, wb);
>  
> @@ -1729,18 +1730,18 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch,
>  {
>    enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
>    int i;
> -  int size, onstack_size;
> +  ULONGEST size, onstack_size;
X
>    gdb_byte *buf = (gdb_byte *) alloca (16);
>    CORE_ADDR ra, ps;
>    struct argument_info
>    {
>      const bfd_byte *contents;
> -    int length;
> +    ULONGEST length;
X
>      int onstack;		/* onstack == 0 => in reg */
>      int align;			/* alignment */
>      union
>      {
> -      int offset;		/* stack offset if on stack.  */
> +      LONGEST offset;		/* stack offset if on stack.  */
>        int regno;		/* regno if in register.  */
>      } u;
>    };
> @@ -1764,9 +1765,9 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch,
>          {
>  	  struct value *arg = args[i];
>  	  struct type *arg_type = check_typedef (value_type (arg));
> -	  fprintf_unfiltered (gdb_stdlog, "%2d: %s %3d ", i,
> +	  fprintf_unfiltered (gdb_stdlog, "%2d: %s %s ", i,

This is not correct, there was formatting to width 3.

>  			      host_address_to_string (arg),
> -			      TYPE_LENGTH (arg_type));
> +			      pulongest (TYPE_LENGTH (arg_type)));
>  	  switch (TYPE_CODE (arg_type))
>  	    {
>  	    case TYPE_CODE_INT:

> diff --git a/gdb/testsuite/gdb.base/structs-longest-bitpos.c b/gdb/testsuite/gdb.base/structs-longest-bitpos.c
> new file mode 100644
> index 0000000..6fb4614
> --- /dev/null
> +++ b/gdb/testsuite/gdb.base/structs-longest-bitpos.c
> @@ -0,0 +1,28 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> +   Copyright 2012 Free Software Foundation, Inc.
> +
> +   This program is free software; you can redistribute it and/or modify
> +   it under the terms of the GNU General Public License as published by
> +   the Free Software Foundation; either version 3 of the License, or
> +   (at your option) any later version.
> +
> +   This program is distributed in the hope that it will be useful,
> +   but WITHOUT ANY WARRANTY; without even the implied warranty of
> +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> +   GNU General Public License for more details.
> +
> +   You should have received a copy of the GNU General Public License
> +   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
> +
> +struct foo
> +{
> +  char buf[0xffff000000];
> +  char buf2[2];
> +} *f;
> +
> +int
> +main ()

This is not C++:
main (void)

> +{
> +  return 0;
> +}
> diff --git a/gdb/testsuite/gdb.base/structs-longest-bitpos.exp b/gdb/testsuite/gdb.base/structs-longest-bitpos.exp
> new file mode 100644
> index 0000000..ba49518
> --- /dev/null
> +++ b/gdb/testsuite/gdb.base/structs-longest-bitpos.exp
> @@ -0,0 +1,30 @@
> +# This testcase is part of GDB, the GNU debugger.
> +
> +# Copyright 2012 Free Software Foundation, Inc.
> +
> +# This program is free software; you can redistribute it and/or modify
> +# it under the terms of the GNU General Public License as published by
> +# the Free Software Foundation; either version 3 of the License, or
> +# (at your option) any later version.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> +# GNU General Public License for more details.
> +#
> +# You should have received a copy of the GNU General Public License
> +# along with this program.  If not, see <http://www.gnu.org/licenses/>.
> +
> +set testfile "structs-longest-bitpos"
> +set srcfile ${testfile}.c
> +set binfile ${objdir}/${subdir}/${testfile}
> +
> +if { [prepare_for_testing structs-longest-bitpos.exp "structs-longest-bitpos" "" {debug}] } {

It can be just (voluntary, FYI):
   if { [prepare_for_testing ${testfile}.exp ${testfile}] } {


> +    return -1
> +}
> +
> +# The array size should not overflow
> +gdb_test "print &f->buf" "= \\(char \\(\\*\\)\\\[1099494850560\\\]\\) 0x0"

It can be just (voluntary, FYI):
   gdb_test "print &f->buf" {= \(char \(\*\)\[1099494850560\]\) 0x0}


> +
> +# The offset should not overflow
> +gdb_test "print &f->buf2" "= \\(char \\(\\*\\)\\\[2\\\]\\) 0xffff000000"

It can be just (voluntary, FYI):
   gdb_test "print &f->buf2" {= \(char \(\*\)\[2\]\) 0xffff000000}



Thanks,
Jan


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]