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

7a6771
http://sourceware.org/ml/gdb-patches/2012-09/msg00631.html
7a6771
Subject: [PATCH 1/4] Expand bitpos and type.length to LONGEST and ULONGEST
7a6771
7a6771
7a6771
--MP_/yp5f+W_ED2JtUlSyBi8xujr
7a6771
Content-Type: text/plain; charset=US-ASCII
7a6771
Content-Transfer-Encoding: 7bit
7a6771
Content-Disposition: inline
7a6771
7a6771
Hi,
7a6771
7a6771
This is patch 1/4, which implements the bulk of the changes in type
7a6771
length and bitpos/type offset. I have verified that there are no
7a6771
regressions resulting from this patch by running the testsuite on
7a6771
Fedora 16 x86_64.  Patch and changelog attached.
7a6771
7a6771
Regards,
7a6771
Siddhesh
7a6771
7a6771
--MP_/yp5f+W_ED2JtUlSyBi8xujr
7a6771
Content-Type: text/plain
7a6771
Content-Transfer-Encoding: quoted-printable
7a6771
Content-Disposition: attachment; filename=ChangeLog-main
7a6771
7a6771
gdb/ChangeLog
7a6771
7a6771
2012-08-05  Siddhesh Poyarekar  <siddhesh@redhat.com>
7a6771
7a6771
	* ada-lang.c (fat_pntr_bounds_bitpos): Return LONGEST.
7a6771
	(fat_pntr_data_bitpos): Likewise.
7a6771
	(desc_bound_bitpos): Likewise.
7a6771
	(constrained_packed_array_type): Expand ELT_BITS parameter to
7a6771
	LONGEST.
7a6771
	(move_bits): Expand parameters SRC_OFFSET and N to LONGEST.
7a6771
	(cond_offset_host): Expand parameter OFFSET to LONGEST.
7a6771
	(cond_offset_target): Likewise.
7a6771
	(ada_type_of_array): Expand ARRAY_BITSIZE to LONGEST.
7a6771
	(decode_constrained_packed_array_type): Expand BITS to LONGEST.
7a6771
	(decode_constrained_packed_array): Expand BIT_POS to LONGEST.
7a6771
	(ada_value_primitive_packed_val): Expand parameter OFFSET to
7a6771
	LONGEST.  Expand TARG, NTARG and NEW_OFFSET to LONGEST.
7a6771
	(ada_value_assign): Expand FROM_SIZE to LONGEST.
7a6771
	(value_assign_to_component): Expand BITS to LONGEST.
7a6771
	(ensure_lval): Expand LEN to LONGEST.
7a6771
	(value_pointer): Expand LEN to ULONGEST.
7a6771
	(value_tag_from_contents_and_address): Expand TAG_BYTE_OFFSET to
7a6771
	LONGEST.
7a6771
	(ada_value_primitive_field): Expand parameter OFFSET to LONGEST.
7a6771
	Expand bit_pos to LONGEST.
7a6771
	(find_struct_field): Expand parameters OFFSET and BYTE_OFFSET_P to
7a6771
	LONGEST.  Expand BIT_POS and FLD_OFFSET to LONGEST.
7a6771
	(ada_search_struct_field): Expand parameter OFFSET to LONGEST.
7a6771
	Expand VAR_OFFSET to LONGEST.
7a6771
	(ada_index_struct_field): Expand parameters INDEX and OFFSET to
7a6771
	LONGEST.
7a6771
	(ada_index_struct_field_1): Expand parameters INDEX_P and OFFSET
7a6771
	to LONGEST.
7a6771
	(ada_value_struct_elt): Expand BYTE_OFFSET to LONGEST.
7a6771
	(align_value): Return ULONGEST.  Expand parameter OFF and
7a6771
	ALIGNMENT to ULONGEST.
7a6771
	(ada_template_to_fixed_record_type_1): Expand OFF, BIT_LEN and
7a6771
	fld_bit_len to LONGEST.  Expand FIELD_OFFSET to LONGEST.  Use
7a6771
	pulongest function to print TYPE_LENGTH.
7a6771
	(to_fixed_array_type): Expand LEN to LONGEST.
7a6771
	* ada-lang.h (ada_val_print): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.
7a6771
	(ada_printstr): Expand parameter LENGTH to ULONGEST.
7a6771
	(ada_value_primitive_packed_val): Expand parameter OFFSET to
7a6771
	LONGEST.
7a6771
	* ada-typeprint.c (ada_print_type): Use pulongest to print
7a6771
	TYPE_LENGTH.
7a6771
	* ada-valprint.c (val_print_packed_array_elements): Expand ELTLEN
7a6771
	to ULONGEST.
7a6771
	(char_at): Expand parameter I to LONGEST.
7a6771
	(printstr): Expand parameter LENGTH, I, REP1, REPS to ULONGEST.
7a6771
	Use pulongest to format print REPS.
7a6771
	(ada_printstr): Expand parameter LENGTH to LONGEST.
7a6771
	(ada_val_print): Expand parameter EMBEDDED_OFFSET to LONGEST.
7a6771
	(ada_val_print_array): Expand ELTLEN, LEN to ULONGEST and TEMP_LEN
7a6771
	to LONGEST.
7a6771
	(ada_val_print_1): Expand parameter OFFSET to LONGEST.
7a6771
	(print_variant_part): Expand parameters OFFSET and OUTER_OFFSET to
7a6771
	LONGEST.
7a6771
	(print_field_values): Likewise.  Expand BIT_POS to LONGEST.
7a6771
	* annotate.c (annotate_array_section_begin): Expand parameter
7a6771
	IDX to LONGEST.  Use plongest to format-print IDX.
7a6771
	(annotate_elt_rep): Expand parameter REPCOUNT to ULONGEST.  Use
7a6771
	plongest to format-print REPCOUNT.
7a6771
	* annotate.h: Likewise.
7a6771
	* arm-linux-nat.c (arm_linux_region_ok_for_hw_watchpoint):
7a6771
	Expand parameter parameter LEN to LONGEST.
7a6771
	* ax-gdb.c (gen_left_shift): Expand parameter DISTANCE to LONGEST.
7a6771
	(gen_offset): Expand parameter OFFSET to LONGEST.
7a6771
	(gen_bitfield_ref): Expand parameters START, END to LONGEST.
7a6771
	Expand BOUND_START, BOUND_END, OFFSET to LONGEST.
7a6771
	(gen_primitive_field): Expand parameter OFFSET to LONGEST.
7a6771
	(gen_struct_ref_recursive): Likewise.
7a6771
	* ax-general.c (ax_trace_quick): Expand parameter N to LONGEST.
7a6771
	* ax.h (ax_trace_quick): Likewise.
7a6771
	* breakpoint.c (breakpoint_address_match_range): Expand parameter
7a6771
	LEN1 to LONGEST.
7a6771
	(can_use_hardware_watchpoint): Expand LEN to LONGEST.
7a6771
	* breakpoint.h (struct bp_target_info): Expand member LENGTH to
7a6771
	LONGEST.
7a6771
	(struct bp_location): Likewise.
7a6771
	* c-lang.c (c_printstr): Expand parameter LENGTH to ULONGEST.
7a6771
	(evaluate_subexp_c): Expand ELEMENT_SIZE, I to LONGEST.
7a6771
	* c-lang.h (c_val_print): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.
7a6771
	(c_printstr): Expand parameter LENGTH to ULONGEST.
7a6771
	(cp_print_value_fields): Expand parameter OFFSET to LONGEST.
7a6771
	(cp_print_value_fields_rtti): Likewise.
7a6771
	* c-typeprint.c (c_type_print_varspec_suffix): Remove cast down to
7a6771
	int and use plongest to print LONGEST.
7a6771
	* c-valprint.c (c_val_print): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.  Expand OFFSET to LONGEST, ELTLEN to ULONGEST.
7a6771
	(c_value_print): Expand TOP to LONGEST.
7a6771
	* cp-abi.c (baseclass_offset): Return LONGEST.  Expand parameter
7a6771
	EMBEDDED_OFFSET to LONGEST.  Expand RES to LONGEST.
7a6771
	(value_virtual_fn_field): Expand parameter OFFSET to LONGEST.
7a6771
	(value_rtti_type): Expand parameter TOP to point to LONGEST.
7a6771
	* cp-abi.h (value_virtual_fn_field): Expand OFFSET to LONGEST.
7a6771
	(value_rtti_type): Expand TOP to point to LONGEST.
7a6771
	(baseclass_offset): Return LONGEST.  Expand parameter
7a6771
	EMBEDDED_OFFSET to LONGEST.
7a6771
	(struct cp_abi_ops): Expand parameter OFFSET for VIRTUAL_FN_FIELD
7a6771
	to LONGEST.  Expand parameter TOP to point to LONGEST in
7a6771
	VALUE_RTTI_TYPE.  Return LONGEST from BASECLASS_OFFSET and expand
7a6771
	parameter EMBEDDED_OFFSET to LONGEST.
7a6771
	* cp-valprint.c (cp_print_value_fields): Expand parameter OFFSET
7a6771
	to LONGEST.  Expand I_OFFSET to LONGEST.
7a6771
	(cp_print_value_fields_rtti): Expand parameter OFFSET to
7a6771
	LONGEST.  Expand TOP to LONGEST.
7a6771
	(cp_print_value): Expand parameter OFFSET to LONGEST.  Expand
7a6771
	THISOFFSET, BOFFSET to LONGEST.
7a6771
	* d-lang.h (d_val_print): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.
7a6771
	* d-valprint.c (dynamic_array_type): Likewise.
7a6771
	(d_val_print): Likewise.
7a6771
	* doublest.c (floatformat_from_length): Expand parameter LEN to
7a6771
	LONGEST.  Use plongest to format string for LONGEST.
7a6771
	* dwarf2loc.c (copy_bitwise): Expand parameters DEST_OFFSET_BITS,
7a6771
	BIT_COUNT to ULONGEST.  Rename parameter SOURCE_OFFSET_BITS to
7a6771
	SOURCE_OFFSET and expand to ULONGEST.  New variable
7a6771
	SOURCE_OFFSET_BITS.
7a6771
	(read_pieced_value): Expand OFFSET, DEST_OFFSET_BITS,
7a6771
	SOURCE_OFFSET_BITS, SOURCE_OFFSET to LONGEST.  Expand TYPE_LEN,
7a6771
	THIS_SIZE, THIS_SIZE_BITS to ULONGEST.
7a6771
	(write_pieced_value): Likewise.
7a6771
	(check_pieced_value_bits): Expand parameters BIT_OFFSET and
7a6771
	BIT_LENGTH to LONGEST.  Expand THIS_SIZE_BITS to ULONGEST.
7a6771
	(check_pieced_value_validity): Expand parameters BIT_OFFSET and
7a6771
	BIT_LENGTH to LONGEST.
7a6771
	(check_pieced_synthetic_pointer): Likewise.
7a6771
	(indirect_pieced_value): Expand BIT_LENGTH, BYTE_OFFSET and
7a6771
	BIT_OFFSET to LONGEST.
7a6771
	(dwarf2_evaluate_loc_desc_full): Expand N to ULONGEST.
7a6771
	* dwarf2read.c (dwarf2_const_value_length_mismatch_complaint):
7a6771
	Expand parameters ARG2 and ARG3 to LONGEST.  Use plongest to
7a6771
	print ARG2 and ARG3.
7a6771
	(dwarf2_add_field): Expand ANONYMOUS_SIZE, BIT_OFFSET to
7a6771
	LONGEST.
7a6771
	* eval.c (evaluate_struct_tuple): Expand BITPOS to LONGEST.
7a6771
	(init_array_element): Expand ELEMENT_SIZE to LONGEST.
7a6771
	(binop_promote): Expand PROMOTED_LEN1, PROMOTED_LEN2, RESULT_LEN
7a6771
	to ULONGEST.
7a6771
	(evaluate_subexp_standard): Expand MEM_OFFSET, TOP, ELEMENT_SIZE
7a6771
	to LONGEST.
7a6771
	* f-lang.c (f_printstr): Expand parameter LENGTH to ULONGEST.
7a6771
	* f-lang.h (f_val_print): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.
7a6771
	* f-valprint.c (f77_array_offset_tbl): Make LONGEST.
7a6771
	(f77_create_arrayprint_offset_tbl): Expand ELTLEN to LONGEST.
7a6771
	(f77_print_array_1): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.  Expand I to LONGEST.
7a6771
	(f77_print_array): Expand parameter EMBEDDED_OFFSET to LONGEST.
7a6771
	(f_val_print): Likewise.  Expand OFFSET to LONGEST.
7a6771
	* findvar.c (default_value_from_register): Expand LEN to LONGEST.
7a6771
	(read_frame_register_value): Expand OFFSET, REG_OFFSET, LEN,
7a6771
	REG_LEN to LONGEST.
7a6771
	* frame.c (get_frame_register_bytes): Expand parameter LEN to
7a6771
	LONGEST.
7a6771
	* frame.h (get_frame_register_bytes): Likewise.
7a6771
	* gdbtypes.c (init_type): Expand parameter LENGTH to LONGEST.
7a6771
	(is_unique_ancestor_worker): Expand parameters OFFSET,
7a6771
	EMBEDDED_OFFSET to LONGEST.  Expand THIS_OFFSET to LONGEST.
7a6771
	(is_unique_ancestor): Expand OFFSET to LONGEST.
7a6771
	(recursive_dump_type): Use pulongest to format print TYPE_LENGTH.
7a6771
	Use plongest to format print TYPE_FIELD_BITPOS.
7a6771
	(arch_type): Expand parameter LENGTH to LONGEST.
7a6771
	* gdbtypes.h (struct type.main_type.fld_bnds.fields): Expand
7a6771
	member BITPOS to LONGEST.
7a6771
	(struct type): Expand member LENGTH to ULONGEST.
7a6771
	(init_type): Expand parameter LENGTH to LONGEST.
7a6771
	(arch_type): Likewise.
7a6771
	* gnu-v2-abi.c (gnuv2_virtual_fn_field): Expand parameter OFFSET
7a6771
	to LONGEST.
7a6771
	(gnuv2_value_rtti_type): Expand parameter TOP to point to LONGEST.
7a6771
	(gnuv2_baseclass_offset): Return LONGEST.  Expand parameter
7a6771
	EMBEDDED_OFFSET to LONGEST.  Expand FIELD_OFFSET, BOFFSET,
7a6771
	FIELD_LENGTH to LONGEST.
7a6771
	* gnu-v3-abi.c (build_gdb_vtable_type): Expand OFFSET to LONGEST.
7a6771
	(vtable_address_point_offset): Return LONGEST.
7a6771
	(gnuv3_rtti_type): Expand parameter TOP_P to point to LONGEST.
7a6771
	(gnuv3_virtual_fn_field): Expand parameter OFFSET to LONGEST.
7a6771
	(gnuv3_baseclass_offset): Return LONGEST.  Expand parameter
7a6771
	EMBEDDED_OFSET to LONGEST.  Expand CUR_BASE_OFFSET, BASE_OFFSET to
7a6771
	LONGEST.
7a6771
	(gnuv3_find_method_in): Expand POS to LONGEST.
7a6771
	* go-lang.h (go_val_print): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.
7a6771
	* go-valprint.c (print_go_string): Likewise.
7a6771
	(go_val_print): Likewise.
7a6771
	* i386-nat.c (i386_handle_nonaligned_watchpoint): Expand
7a6771
	parameter LEN to LONGEST.
7a6771
	(i386_region_ok_for_watchpoint): Likewise.
7a6771
	* inf-ttrace.c (inf_ttrace_region_ok_for_hw_watchpoint): Expand
7a6771
	parameter LEN to LONGEST.
7a6771
	* jv-lang.c (java_link_class_type): Expand BOFFSET to LONGEST.
7a6771
	(java_printstr): Expand parameter LENGTH to ULONGEST.
7a6771
	* jv-lang.h (java_val_print): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.
7a6771
	* jv-valprint.c (java_print_value_fields): Expand parameter OFFSET
7a6771
	to LONGEST.
7a6771
	(java_val_print): Expand parameter EMBEDDED_OFFSET to LONGEST.
7a6771
	* language.c (unk_lang_printstr): Expand parameter LENGTH to
7a6771
	ULONGEST.
7a6771
	(unk_lang_val_print): Expand parameter EMBEDDED_OFFSET to LONGEST.
7a6771
	* language.h (language_defn): Expand parameter LENGTH of
7a6771
	LA_PRINTSTR to ULONGEST.  Expand parameter EMBEDDED_OFFSET of
7a6771
	LA_VAL_PRINT to LONGEST.
7a6771
	* m2-lang.c (m2_printstr): Expand parameter LENGTH to ULONGEST.
7a6771
	Expand I, REP1, REPS to ULONGEST.  Use pulongest to format print
7a6771
	REPS.
7a6771
	* m2-lang.h (m2_val_print): Expand parameter embedded_offset to
7a6771
	LONGEST.
7a6771
	* m2-typeprint.c (m2_array): New variable VAL.  Use pulongest to
7a6771
	* format print VAL.
7a6771
	(m2_enum): expand LASTVAL to LONGEST.
7a6771
	* m2-valprint.c (m2_print_long_set): Expand parameter
7a6771
	EMBEDDED_OFFSET to LONGEST.
7a6771
	(m2_print_unbounded_array): Likewise.
7a6771
	(m2_print_array_contents): Likewise.
7a6771
	(m2_val_print): Expand parameter EMBEDDED_OFFSET to LONGEST.
7a6771
	Expand I, LEN, TEMP_LEN to ULONGEST.
7a6771
	* memrange.c (mem_ranges_overlap): Expand parameters LEN1, LEN2 to
7a6771
	LONGEST.
7a6771
	* memrange.h (struct mem_range): Expand member LENGTH to LONGEST.
7a6771
	(mem_ranges_overlap): Expand parameters LEN1, LEN2 to LONGEST.
7a6771
	* mips-linux-nat.c (mips_linux_region_ok_for_hw_watchpoint):
7a6771
	Expand parameter LEN to LONGEST.
7a6771
	* objc-lang.c (objc_printstr): Expand parameter LENGTH to
7a6771
	ULONGEST.  Expand I, REP1, REPS to ULONGEST.  use pulongest to
7a6771
	format print REPS.
7a6771
	* opencl-lang.c (lookup_opencl_vector_type): Expand parameter
7a6771
	EL_LENGTH to ULONGEST.  Expand LENGTH to ULONGEST.
7a6771
	(lval_func_read): Expand OFFSET, N, I, J and ELSIZE to LONGEST.
7a6771
	(lval_func_write): Likewise.
7a6771
	(lval_func_check_validity): Expand parameter LENGTH to LONGEST.
7a6771
	Expand ELSIZE, START, END, I, STARTREST, ENDREST, COMP_OFFSET,
7a6771
	COMP_LENGTH to LONGEST.
7a6771
	(lval_func_check_any_valid): Expand ELSIZE to LONGEST.
7a6771
	(lval_func_check_synthetic_pointer): Expand parameters OFFSET and
7a6771
	LENGTH to LONGEST.  Expand ELSIZE, START, END, I, STARTREST,
7a6771
	ENDREST, COMP_LENGTH, COMP_OFFSET to LONGEST.
7a6771
	* p-lang.c (is_pascal_string_type): Expand parameters LENGTH_POS,
7a6771
	STRING_POS, LENGTH_SIZE to point to LONGEST.
7a6771
	(pascal_printstr): Expand parameter LENGTH to ULONGEST.  Expand
7a6771
	I, REP1, REPS to ULONGEST.  Use pulongest to format print REPS.
7a6771
	* p-lang.h (pascal_val_print): Expand parameter EMBEDDED_OFFSET
7a6771
	to LONGEST.
7a6771
	(is_pascal_string_type): Expand parameters LENGTH_POS, STRING_POS,
7a6771
	LENGTH_SIZE to point to LONGEST.
7a6771
	(pascal_printstr): Expand parameter LENGTH to ULONGEST.
7a6771
	(pascal_object_print_value_fields): Expand parameter OFFSET to
7a6771
	LONGEST.
7a6771
	* p-valprint.c (pascal_val_print): Expand parameter
7a6771
	EMBEDDED_OFFSET to LONGEST.  Expand ELTLEN to ULONGEST.  Expand
7a6771
	LENGTH_SIZE, LENGTH_POS, STRING_POS to LONGEST.
7a6771
	(pascal_object_print_value_fields): Expand parameter OFFSET to
7a6771
	LONGEST.
7a6771
	(pascal_object_print_value): Likewise.  Expand BOFFSET,
7a6771
	THISOFFSET to LONGEST.
7a6771
	* ppc-linux-nat.c (ppc_linux_region_ok_for_hw_watchpoint):
7a6771
	Expand parameter LEN to point to LONGEST.
7a6771
	* printcmd.c (print_formatted): Expand LEN to LONGEST.
7a6771
	(print_scalar_formatted): Likewise.
7a6771
	* procfs.c (procfs_region_ok_for_hw_watchpoint): Expand
7a6771
	parameter LEN to LONGEST.
7a6771
	* python/py-prettyprint.c (apply_val_pretty_printer): Expand
7a6771
	parameter EMBEDDED_OFFSET to LONGEST.
7a6771
	* python/python.h (apply_val_pretty_printer): Likewise.
7a6771
	* regcache.c (regcache_xfer_part): Expand parameter OFFSET to
7a6771
	LONGEST.
7a6771
	(regcache_raw_read_part): Likewise.
7a6771
	(regcache_raw_write_part): Likewise.
7a6771
	(regcache_cooked_read_part): Likewise.
7a6771
	(regcache_cooked_write_part): Likewise.
7a6771
	* regcache.h (regcache_raw_read_part): Likewise.
7a6771
	(regcache_raw_write_part): Likewise.
7a6771
	(regcache_cooked_read_part): Likewise.
7a6771
	(regcache_cooked_write_part): Likewise.
7a6771
	* remote.c (remote_region_ok_for_hw_watchpoint): Expand
7a6771
	parameter LEN to LONGEST.
7a6771
	* s390-nat.c (s390_region_ok_for_hw_watchpoint): Expand
7a6771
	parameter LEN to LONGEST.
7a6771
	* spu-multiarch.c (spu_region_ok_for_hw_watchpoint): Expand
7a6771
	parameter len to LONGEST.
7a6771
	* stack.c (print_frame_nameless_args): Expand parameter START to
7a6771
	LONGEST.
7a6771
	(print_frame_args): Expand HIGHEST_OFFSET, CURRENT_OFFSET,
7a6771
	ARG_SIZE, START to LONGEST.
7a6771
	* symmisc.c (print_symbol): Expand I to ULONGEST.  Use pulongest
7a6771
	to format print TYPE_LENGTH.
7a6771
	* target.c (default_region_ok_for_hw_watchpoint): Expand parameter
7a6771
	LEN to LONGEST.
7a6771
	(debug_to_region_ok_for_hw_watchpoint): Likewise.
7a6771
	* target.h (struct target_ops): Expand parameter LEN to LONGEST
7a6771
	for TO_REGION_OK_FOR_HW_WATCHPOINT.
7a6771
	* tracepoint.c (add_memrange): Expand parameter LEN to LONGEST.
7a6771
	Use plongest to format print LEN.
7a6771
	(collect_symbol): Expand LEN to ULONGEST.  Use pulongest to
7a6771
	format print LEN.
7a6771
	(scope_info): Expand J to LONGEST.  Use pulongest to format
7a6771
	print TYPE_LENGTH.
7a6771
	* typeprint.c (whatis_exp): Expand TOP to LONGEST.
7a6771
	* valarith.c (value_subscripted_rvalue): Expand parameters INDEX
7a6771
	and LOWERBOUND to LONGEST.  Expand ELT_SIZE, ELT_OFFS to ULONGEST.
7a6771
	(value_concat): expand INVAL1LEN and INVAL2LEN to ssize_t.
7a6771
	(value_logical_not): Expand LEN to LONGEST.
7a6771
	(value_strcmp): Expand LEN1, LEN2, I, LEN to LONGEST.
7a6771
	* valops.c (value_allocate_space_in_inferior): Expand parameter
7a6771
	LEN to LONGEST.
7a6771
	(value_cast_structs): Expand TOP to LONGEST.
7a6771
	(value_cast): Expand ELEMENT_LENGTH to ULONGEST.  Expand
7a6771
	VAL_LENGTH to LONGEST.
7a6771
	(dynamic_cast_check_1): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.  Expand OFFSET to LONGEST.
7a6771
	(dynamic_cast_check_2): Likewise.
7a6771
	(value_dynamic_cast): Expand TOP to LONGEST.
7a6771
	(read_value_memory): Expand EMBEDDED_OFFSET to LONGEST.
7a6771
	(value_assign): Expand CHANGED_LEN, OFFSET to LONGEST.
7a6771
	(value_array): Expand TYPELENGTH to ULONGEST.
7a6771
	(update_search_result): Expand parameters LAST_BOFFSET, BOFFSET
7a6771
	to LONGEST.
7a6771
	(do_search_struct_field): Expand parameter OFFSET, LAST_BOFFSET
7a6771
	to LONGEST.  Expand NEW_OFFSET, BOFFSET to LONGEST.
7a6771
	(search_struct_field): Expand parameter OFFSET to LONGEST.
7a6771
	Expand BOFFSET to LONGEST.
7a6771
	(search_struct_method): Expand parameter OFFSET to LONGEST.
7a6771
	Expand BASE_OFFSET, THIS_OFFSET to LONGEST.
7a6771
	(find_method_list): Expand parameters OFFSET, BOFFSET to
7a6771
	LONGEST.  Expand BASE_OFFSET to LONGEST.
7a6771
	(value_find_oload_method_list): Expand parameter BOFFSET to point
7a6771
	to LONGEST.
7a6771
	(find_overload_match): Expand BOFFSET to LONGEST.
7a6771
	(value_struct_elt_for_reference): Expand parameter OFFSET to
7a6771
	LONGEST.  Remove unneeded cast.  Expand BASE_OFFSET to LONGEST.
7a6771
	(value_rtti_indirect_type): Expand parameter TOP to point to
7a6771
	LONGEST.
7a6771
	(value_full_object): Expand parameter XTOP to LONGEST.  Expand
7a6771
	TOP to LONGEST.
7a6771
	* valprint.c (valprint_check_validity): Expand parameter
7a6771
	EMBEDDED_OFFSET to LONGEST.
7a6771
	(generic_val_print): Likewise.
7a6771
	(val_print): Likewise.
7a6771
	(val_print_scalar_formatted): Likewise.
7a6771
	(print_hex_chars): Expand parameter LEN to ULONGEST.
7a6771
	(val_print_array_elements): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST, I to ULONGEST.  Expand LEN, ELTLEN, REP1, REPS to
7a6771
	ULONGEST.  Use pulongest to format print REPS.
7a6771
	(generic_printstr): Expand parameter LENGTH to ULONGEST.
7a6771
	* valprint.h (val_print_array_elements): Expand parameter
7a6771
	EMBEDDED_OFFSET to LONGEST.
7a6771
	(val_print_scalar_formatted): Likewise.
7a6771
	(print_hex_chars): Expand parameter LEN to ULONGEST.
7a6771
	(generic_val_print): Expand parameter EMBEDDED_OFFSET to LONGEST.
7a6771
	(generic_printstr): Expand parameter LENGTH to ULONGEST.
7a6771
	* value.c (struct range): Expand members OFFSET, LENGTH to
7a6771
	LONGEST.
7a6771
	(ranges_overlap): Expand parameters OFFSET1, OFFSET2, LEN1 AND
7a6771
	LEN2 to LONGEST.
7a6771
	(range_contain): Expand parameter OFFSET, LENGTH to LONGEST.
7a6771
	(struct value): Expand members OFFSET, EMBEDDED_OFFSET,
7a6771
	POINTED_TO_OFFSET to LONGEST.
7a6771
	(value_bytes_available): Expand parameters OFFSET, LENGTH to
7a6771
	LONGEST.
7a6771
	(mark_value_bytes_unavailable): Likewise.
7a6771
	(find_first_range_overlap): Likewise.
7a6771
	(value_available_contents_eq): Expand parameters OFFSET1, OFFSET2
7a6771
	and LENGTH to LONGEST.
7a6771
	(value_offset): Return LONGEST.
7a6771
	(set_value_offset): Expand parameter OFFSET to LONGEST.
7a6771
	(value_contents_copy_raw): Expand parameters SRC_OFFSET,
7a6771
	DST_OFFSET, LENGTH to ssize_t.
7a6771
	(value_contents_copy): Likewise.
7a6771
	(value_bits_valid): Expand parameters OFFSET, LENGTH to LONGEST.
7a6771
	(value_bits_synthetic_pointer): Likewise.
7a6771
	(value_embedded_offset): Return LONGEST.
7a6771
	(set_value_embedded_offset): Expand parameter VAL to LONGEST.
7a6771
	(value_pointed_to_offset): Return LONGEST.
7a6771
	(set_value_pointed_to_offset): Expand parameter VAL to LONGEST.
7a6771
	(set_internalvar_component): Expand parameter OFFSET to LONGEST.
7a6771
	(value_primitive_field): Likewise.  Expand BITPOS, BOFFSET,
7a6771
	CONTAINER_BITSIZE to LONGEST.
7a6771
	(value_fn_field): Expand parameter OFFSET to LONGEST.
7a6771
	(unpack_value_bits_as_long_1): Expand parameters EMBEDDED_OFFSET,
7a6771
	BITPOS to LONGEST.  Expand READ_OFFSET to LONGEST.
7a6771
	(unpack_value_bits_as_long): Expand parameter EMBEDED_OFFSET to
7a6771
	LONGEST.
7a6771
	(unpack_value_field_as_long_1): Likewise.  Expand BITPOS to
7a6771
	LONGEST.
7a6771
	(unpack_value_field_as_long): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.
7a6771
	(value_field_bitfield): Likewise.
7a6771
	(modify_field): Expand parameter BITPOS to LONGEST.  Expand
7a6771
	BYTESIZE to LONGEST.
7a6771
	* value.h (value_offset): Return LONGEST.
7a6771
	(set_value_offset): Expand parameter OFFSET to LONGEST.
7a6771
	(value_pointed_to_offset): Return LONGEST.
7a6771
	(set_value_pointed_to_offset): Expand parameter VAL to LONGEST.
7a6771
	(value_embedded_offset): Return LONGEST.
7a6771
	(set_value_embedded_offset): Expand parameter VAL to LONGEST.
7a6771
	(struct lval_funcs): Expand parameters OFFSET and LENGTH to
7a6771
	LONGEST for CHECK_VALIDITY.  Likewise for CHECK_SYNTHETIC_POINTER.
7a6771
	(valprint_check_validity): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.
7a6771
	(value_bits_valid): Expand parameters OFFSET, LENGTH to LONGEST.
7a6771
	(value_bits_synthetic_pointer): Likewise.
7a6771
	(value_bytes_available): Likewise.
7a6771
	(mark_value_bytes_unavailable): Likewise.
7a6771
	(value_available_contents_eq): Fix comment.  Expand parameters
7a6771
	OFFSET1, OFFSET2, LENGTH to LONGEST.
7a6771
	(read_value_memory): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.
7a6771
	(unpack_value_bits_as_long): Expand parameter EMBEDDED_OFFSET to
7a6771
	LONGEST.
7a6771
	(unpack_value_field_as_long): Likewise.
7a6771
	(value_field_bitfield): Likewise.
7a6771
	(value_contents_copy_raw): Expand parameters SRC_OFFSET,
7a6771
	DST_OFFSET, LENGTH to LONGEST.
7a6771
	(value_contents_copy): Likewise.
7a6771
	(value_primitive_field): Expand parameter OFFSET to LONGEST.
7a6771
	(value_rtti_indirect_type): Expand parameter TOP to point to
7a6771
	LONGEST.
7a6771
	(value_full_object): Expand parameter XTOP to LONGEST.
7a6771
	(set_internalvar_component): Expand parameter OFFSET to LONGEST.
7a6771
	(value_fn_field): Expand parameter OFFSET to LONGEST.
7a6771
	(modify_field): Expand parameter BITPOS to LONGEST.
7a6771
	(val_print): Expand parameter EMBEDDED_OFFSET to LONGEST.
7a6771
	(value_allocate_space_in_inferior): Expand parameter LEN to
7a6771
	LONGEST.
7a6771
7a6771
gdb/testsuite/ChangeLog:
7a6771
7a6771
2012-08-05  Siddhesh Poyarekar  <siddhesh@redhat.com>
7a6771
7a6771
	* gdb.base/longest-types.exp: Add test case to get offset of
7a6771
	BUF2.
7a6771
7a6771
--MP_/yp5f+W_ED2JtUlSyBi8xujr
7a6771
Content-Type: text/x-patch
7a6771
Content-Transfer-Encoding: 7bit
7a6771
Content-Disposition: attachment; filename=bitpos-main.patch
7a6771
7a6771
Index: gdb-7.11.50.20160716/gdb/ada-lang.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/ada-lang.c	2016-07-16 14:33:42.053510117 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/ada-lang.c	2016-07-16 14:33:44.527530028 +0200
7a6771
@@ -75,7 +75,7 @@
7a6771
 
7a6771
 static struct value *desc_bounds (struct value *);
7a6771
 
7a6771
-static int fat_pntr_bounds_bitpos (struct type *);
7a6771
+static LONGEST fat_pntr_bounds_bitpos (struct type *);
7a6771
 
7a6771
 static int fat_pntr_bounds_bitsize (struct type *);
7a6771
 
7a6771
@@ -83,13 +83,13 @@
7a6771
 
7a6771
 static struct value *desc_data (struct value *);
7a6771
 
7a6771
-static int fat_pntr_data_bitpos (struct type *);
7a6771
+static LONGEST fat_pntr_data_bitpos (struct type *);
7a6771
 
7a6771
 static int fat_pntr_data_bitsize (struct type *);
7a6771
 
7a6771
 static struct value *desc_one_bound (struct value *, int, int);
7a6771
 
7a6771
-static int desc_bound_bitpos (struct type *, int, int);
7a6771
+static LONGEST desc_bound_bitpos (struct type *, int, int);
7a6771
 
7a6771
 static int desc_bound_bitsize (struct type *, int, int);
7a6771
 
7a6771
@@ -172,7 +172,7 @@
7a6771
 
7a6771
 static struct value *unwrap_value (struct value *);
7a6771
 
7a6771
-static struct type *constrained_packed_array_type (struct type *, long *);
7a6771
+static struct type *constrained_packed_array_type (struct type *, LONGEST *);
7a6771
 
7a6771
 static struct type *decode_constrained_packed_array_type (struct type *);
7a6771
 
7a6771
@@ -187,7 +187,8 @@
7a6771
 static struct value *value_subscript_packed (struct value *, int,
7a6771
                                              struct value **);
7a6771
 
7a6771
-static void move_bits (gdb_byte *, int, const gdb_byte *, int, int, int);
7a6771
+static void move_bits (gdb_byte *, int, const gdb_byte *, LONGEST, LONGEST,
7a6771
+		       int);
7a6771
 
7a6771
 static struct value *coerce_unspec_val_to_type (struct value *,
7a6771
                                                 struct type *);
7a6771
@@ -215,14 +216,14 @@
7a6771
 static struct symbol *standard_lookup (const char *, const struct block *,
7a6771
                                        domain_enum);
7a6771
 
7a6771
-static struct value *ada_search_struct_field (const char *, struct value *, int,
7a6771
+static struct value *ada_search_struct_field (const char *, struct value *, LONGEST,
7a6771
                                               struct type *);
7a6771
 
7a6771
-static struct value *ada_value_primitive_field (struct value *, int, int,
7a6771
+static struct value *ada_value_primitive_field (struct value *, LONGEST, int,
7a6771
                                                 struct type *);
7a6771
 
7a6771
-static int find_struct_field (const char *, struct type *, int,
7a6771
-                              struct type **, int *, int *, int *, int *);
7a6771
+static int find_struct_field (const char *, struct type *, LONGEST,
7a6771
+                              struct type **, LONGEST *, int *, int *, int *);
7a6771
 
7a6771
 static struct value *ada_to_fixed_value_create (struct type *, CORE_ADDR,
7a6771
                                                 struct value *);
7a6771
@@ -236,7 +237,7 @@
7a6771
 static void ada_language_arch_info (struct gdbarch *,
7a6771
 				    struct language_arch_info *);
7a6771
 
7a6771
-static struct value *ada_index_struct_field (int, struct value *, int,
7a6771
+static struct value *ada_index_struct_field (LONGEST, struct value *, LONGEST,
7a6771
 					     struct type *);
7a6771
 
7a6771
 static struct value *assign_aggregate (struct value *, struct value *, 
7a6771
@@ -700,7 +701,7 @@
7a6771
 }
7a6771
 
7a6771
 static const gdb_byte *
7a6771
-cond_offset_host (const gdb_byte *valaddr, long offset)
7a6771
+cond_offset_host (const gdb_byte *valaddr, LONGEST offset)
7a6771
 {
7a6771
   if (valaddr == NULL)
7a6771
     return NULL;
7a6771
@@ -709,7 +710,7 @@
7a6771
 }
7a6771
 
7a6771
 static CORE_ADDR
7a6771
-cond_offset_target (CORE_ADDR address, long offset)
7a6771
+cond_offset_target (CORE_ADDR address, LONGEST offset)
7a6771
 {
7a6771
   if (address == 0)
7a6771
     return 0;
7a6771
@@ -1756,7 +1757,7 @@
7a6771
 /* If TYPE is the type of an array-descriptor (fat pointer),  the bit
7a6771
    position of the field containing the address of the bounds data.  */
7a6771
 
7a6771
-static int
7a6771
+static LONGEST
7a6771
 fat_pntr_bounds_bitpos (struct type *type)
7a6771
 {
7a6771
   return TYPE_FIELD_BITPOS (desc_base_type (type), 1);
7a6771
@@ -1822,7 +1823,7 @@
7a6771
 /* If TYPE is the type of an array-descriptor (fat pointer), the bit
7a6771
    position of the field containing the address of the data.  */
7a6771
 
7a6771
-static int
7a6771
+static LONGEST
7a6771
 fat_pntr_data_bitpos (struct type *type)
7a6771
 {
7a6771
   return TYPE_FIELD_BITPOS (desc_base_type (type), 0);
7a6771
@@ -1857,7 +1858,7 @@
7a6771
    of the Ith lower bound stored in it, if WHICH is 0, and the Ith upper
7a6771
    bound, if WHICH is 1.  The first bound is I=1.  */
7a6771
 
7a6771
-static int
7a6771
+static LONGEST
7a6771
 desc_bound_bitpos (struct type *type, int i, int which)
7a6771
 {
7a6771
   return TYPE_FIELD_BITPOS (desc_base_type (type), 2 * i + which - 2);
7a6771
@@ -2047,7 +2048,7 @@
7a6771
 	         zero, and does not need to be recomputed.  */
7a6771
 	      if (lo < hi)
7a6771
 		{
7a6771
-		  int array_bitsize =
7a6771
+		  LONGEST array_bitsize =
7a6771
 		        (hi - lo + 1) * TYPE_FIELD_BITSIZE (elt_type, 0);
7a6771
 
7a6771
 		  TYPE_LENGTH (array_type) = (array_bitsize + 7) / 8;
7a6771
@@ -2207,7 +2208,7 @@
7a6771
    the length is arbitrary.  */
7a6771
 
7a6771
 static struct type *
7a6771
-constrained_packed_array_type (struct type *type, long *elt_bits)
7a6771
+constrained_packed_array_type (struct type *type, LONGEST *elt_bits)
7a6771
 {
7a6771
   struct type *new_elt_type;
7a6771
   struct type *new_type;
7a6771
@@ -2261,7 +2262,7 @@
7a6771
   char *name;
7a6771
   const char *tail;
7a6771
   struct type *shadow_type;
7a6771
-  long bits;
7a6771
+  LONGEST bits;
7a6771
 
7a6771
   if (!raw_name)
7a6771
     raw_name = ada_type_name (desc_base_type (type));
7a6771
@@ -2332,7 +2333,8 @@
7a6771
  	 array with no wrapper.  In order to interpret the value through
7a6771
  	 the (left-justified) packed array type we just built, we must
7a6771
  	 first left-justify it.  */
7a6771
-      int bit_size, bit_pos;
7a6771
+      int bit_size;
7a6771
+      LONGEST bit_pos;
7a6771
       ULONGEST mod;
7a6771
 
7a6771
       mod = ada_modulus (value_type (arr)) - 1;
7a6771
@@ -2560,7 +2562,7 @@
7a6771
 
7a6771
 struct value *
7a6771
 ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
7a6771
-				long offset, int bit_offset, int bit_size,
7a6771
+				LONGEST offset, int bit_offset, int bit_size,
7a6771
                                 struct type *type)
7a6771
 {
7a6771
   struct value *v;
7a6771
@@ -2633,7 +2635,7 @@
7a6771
 
7a6771
   if (obj != NULL)
7a6771
     {
7a6771
-      long new_offset = offset;
7a6771
+      LONGEST new_offset = offset;
7a6771
 
7a6771
       set_value_component_location (v, obj);
7a6771
       set_value_bitpos (v, bit_offset + value_bitpos (obj));
7a6771
@@ -2681,7 +2683,7 @@
7a6771
    not overlap.  */
7a6771
 static void
7a6771
 move_bits (gdb_byte *target, int targ_offset, const gdb_byte *source,
7a6771
-	   int src_offset, int n, int bits_big_endian_p)
7a6771
+	   LONGEST src_offset, LONGEST n, int bits_big_endian_p)
7a6771
 {
7a6771
   unsigned int accum, mask;
7a6771
   int accum_bits, chunk_size;
7a6771
@@ -2771,7 +2773,7 @@
7a6771
     {
7a6771
       int len = (value_bitpos (toval)
7a6771
 		 + bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
7a6771
-      int from_size;
7a6771
+      LONGEST from_size;
7a6771
       gdb_byte *buffer = (gdb_byte *) alloca (len);
7a6771
       struct value *val;
7a6771
       CORE_ADDR to_addr = value_address (toval);
7a6771
@@ -2822,7 +2824,7 @@
7a6771
     (LONGEST)  (value_address (component) - value_address (container));
7a6771
   int bit_offset_in_container =
7a6771
     value_bitpos (component) - value_bitpos (container);
7a6771
-  int bits;
7a6771
+  LONGEST bits;
7a6771
 
7a6771
   val = value_cast (value_type (component), val);
7a6771
 
7a6771
@@ -4480,7 +4482,7 @@
7a6771
   if (VALUE_LVAL (val) == not_lval
7a6771
       || VALUE_LVAL (val) == lval_internalvar)
7a6771
     {
7a6771
-      int len = TYPE_LENGTH (ada_check_typedef (value_type (val)));
7a6771
+      LONGEST len = TYPE_LENGTH (ada_check_typedef (value_type (val)));
7a6771
       const CORE_ADDR addr =
7a6771
         value_as_long (value_allocate_space_in_inferior (len));
7a6771
 
7a6771
@@ -4564,7 +4566,7 @@
7a6771
 value_pointer (struct value *value, struct type *type)
7a6771
 {
7a6771
   struct gdbarch *gdbarch = get_type_arch (type);
7a6771
-  unsigned len = TYPE_LENGTH (type);
7a6771
+  ULONGEST len = TYPE_LENGTH (type);
7a6771
   gdb_byte *buf = (gdb_byte *) alloca (len);
7a6771
   CORE_ADDR addr;
7a6771
 
7a6771
@@ -6799,7 +6801,7 @@
7a6771
 				     const gdb_byte *valaddr,
7a6771
                                      CORE_ADDR address)
7a6771
 {
7a6771
-  int tag_byte_offset;
7a6771
+  LONGEST tag_byte_offset;
7a6771
   struct type *tag_type;
7a6771
 
7a6771
   if (find_struct_field ("_tag", type, 0, &tag_type, &tag_byte_offset,
7a6771
@@ -7280,7 +7282,7 @@
7a6771
    only in that it can handle packed values of arbitrary type.  */
7a6771
 
7a6771
 static struct value *
7a6771
-ada_value_primitive_field (struct value *arg1, int offset, int fieldno,
7a6771
+ada_value_primitive_field (struct value *arg1, LONGEST offset, int fieldno,
7a6771
                            struct type *arg_type)
7a6771
 {
7a6771
   struct type *type;
7a6771
@@ -7292,7 +7294,7 @@
7a6771
 
7a6771
   if (TYPE_FIELD_BITSIZE (arg_type, fieldno) != 0)
7a6771
     {
7a6771
-      int bit_pos = TYPE_FIELD_BITPOS (arg_type, fieldno);
7a6771
+      LONGEST bit_pos = TYPE_FIELD_BITPOS (arg_type, fieldno);
7a6771
       int bit_size = TYPE_FIELD_BITSIZE (arg_type, fieldno);
7a6771
 
7a6771
       return ada_value_primitive_packed_val (arg1, value_contents (arg1),
7a6771
@@ -7319,9 +7321,9 @@
7a6771
    Returns 1 if found, 0 otherwise.  */
7a6771
 
7a6771
 static int
7a6771
-find_struct_field (const char *name, struct type *type, int offset,
7a6771
+find_struct_field (const char *name, struct type *type, LONGEST offset,
7a6771
                    struct type **field_type_p,
7a6771
-                   int *byte_offset_p, int *bit_offset_p, int *bit_size_p,
7a6771
+		   LONGEST *byte_offset_p, int *bit_offset_p, int *bit_size_p,
7a6771
 		   int *index_p)
7a6771
 {
7a6771
   int i;
7a6771
@@ -7339,8 +7341,8 @@
7a6771
 
7a6771
   for (i = 0; i < TYPE_NFIELDS (type); i += 1)
7a6771
     {
7a6771
-      int bit_pos = TYPE_FIELD_BITPOS (type, i);
7a6771
-      int fld_offset = offset + bit_pos / 8;
7a6771
+      LONGEST bit_pos = TYPE_FIELD_BITPOS (type, i);
7a6771
+      LONGEST fld_offset = offset + bit_pos / 8;
7a6771
       const char *t_field_name = TYPE_FIELD_NAME (type, i);
7a6771
 
7a6771
       if (t_field_name == NULL)
7a6771
@@ -7410,7 +7412,7 @@
7a6771
    Searches recursively through wrapper fields (e.g., '_parent').  */
7a6771
 
7a6771
 static struct value *
7a6771
-ada_search_struct_field (const char *name, struct value *arg, int offset,
7a6771
+ada_search_struct_field (const char *name, struct value *arg, LONGEST offset,
7a6771
                          struct type *type)
7a6771
 {
7a6771
   int i;
7a6771
@@ -7443,7 +7445,7 @@
7a6771
           int j;
7a6771
           struct type *field_type = ada_check_typedef (TYPE_FIELD_TYPE (type,
7a6771
 									i));
7a6771
-          int var_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
7a6771
+	  LONGEST var_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
7a6771
 
7a6771
           for (j = 0; j < TYPE_NFIELDS (field_type); j += 1)
7a6771
             {
7a6771
@@ -7461,8 +7463,8 @@
7a6771
   return NULL;
7a6771
 }
7a6771
 
7a6771
-static struct value *ada_index_struct_field_1 (int *, struct value *,
7a6771
-					       int, struct type *);
7a6771
+static struct value *ada_index_struct_field_1 (LONGEST *, struct value *,
7a6771
+					       LONGEST, struct type *);
7a6771
 
7a6771
 
7a6771
 /* Return field #INDEX in ARG, where the index is that returned by
7a6771
@@ -7471,7 +7473,7 @@
7a6771
  * If found, return value, else return NULL.  */
7a6771
 
7a6771
 static struct value *
7a6771
-ada_index_struct_field (int index, struct value *arg, int offset,
7a6771
+ada_index_struct_field (LONGEST index, struct value *arg, LONGEST offset,
7a6771
 			struct type *type)
7a6771
 {
7a6771
   return ada_index_struct_field_1 (&index, arg, offset, type);
7a6771
@@ -7483,7 +7485,7 @@
7a6771
  * *INDEX_P.  */
7a6771
 
7a6771
 static struct value *
7a6771
-ada_index_struct_field_1 (int *index_p, struct value *arg, int offset,
7a6771
+ada_index_struct_field_1 (LONGEST *index_p, struct value *arg, LONGEST offset,
7a6771
 			  struct type *type)
7a6771
 {
7a6771
   int i;
7a6771
@@ -7573,7 +7575,8 @@
7a6771
     v = ada_search_struct_field (name, arg, 0, t);
7a6771
   else
7a6771
     {
7a6771
-      int bit_offset, bit_size, byte_offset;
7a6771
+      int bit_offset, bit_size;
7a6771
+      LONGEST byte_offset;
7a6771
       struct type *field_type;
7a6771
       CORE_ADDR address;
7a6771
 
7a6771
@@ -7904,8 +7907,8 @@
7a6771
 /* Return OFF rounded upward if necessary to a multiple of
7a6771
    ALIGNMENT (a power of 2).  */
7a6771
 
7a6771
-static unsigned int
7a6771
-align_value (unsigned int off, unsigned int alignment)
7a6771
+static ULONGEST
7a6771
+align_value (ULONGEST off, ULONGEST alignment)
7a6771
 {
7a6771
   return (off + alignment - 1) & ~(alignment - 1);
7a6771
 }
7a6771
@@ -8299,10 +8302,9 @@
7a6771
   struct value *mark = value_mark ();
7a6771
   struct value *dval;
7a6771
   struct type *rtype;
7a6771
-  int nfields, bit_len;
7a6771
+  int nfields;
7a6771
   int variant_field;
7a6771
-  long off;
7a6771
-  int fld_bit_len;
7a6771
+  LONGEST off, bit_len, fld_bit_len;
7a6771
   int f;
7a6771
 
7a6771
   /* Compute the number of fields in this record type that are going
7a6771
@@ -8380,7 +8382,7 @@
7a6771
 	     that follow this one.  */
7a6771
 	  if (ada_is_aligner_type (field_type))
7a6771
 	    {
7a6771
-	      long field_offset = TYPE_FIELD_BITPOS (field_type, f);
7a6771
+	      LONGEST field_offset = TYPE_FIELD_BITPOS (field_type, f);
7a6771
 
7a6771
 	      field_valaddr = cond_offset_host (field_valaddr, field_offset);
7a6771
 	      field_address = cond_offset_target (field_address, field_offset);
7a6771
@@ -8516,11 +8518,11 @@
7a6771
   if (TYPE_LENGTH (type) <= 0)
7a6771
     {
7a6771
       if (TYPE_NAME (rtype))
7a6771
-	warning (_("Invalid type size for `%s' detected: %d."),
7a6771
-		 TYPE_NAME (rtype), TYPE_LENGTH (type));
7a6771
+	warning (_("Invalid type size for `%s' detected: %s."),
7a6771
+		 TYPE_NAME (rtype), pulongest (TYPE_LENGTH (type)));
7a6771
       else
7a6771
-	warning (_("Invalid type size for <unnamed> detected: %d."),
7a6771
-		 TYPE_LENGTH (type));
7a6771
+	warning (_("Invalid type size for <unnamed> detected: %s."),
7a6771
+		 pulongest (TYPE_LENGTH (type)));
7a6771
     }
7a6771
   else
7a6771
     {
7a6771
@@ -8987,7 +8989,8 @@
7a6771
 	 type was a regular (non-packed) array type.  As a result, the
7a6771
 	 bitsize of the array elements needs to be set again, and the array
7a6771
 	 length needs to be recomputed based on that bitsize.  */
7a6771
-      int len = TYPE_LENGTH (result) / TYPE_LENGTH (TYPE_TARGET_TYPE (result));
7a6771
+      LONGEST len = (TYPE_LENGTH (result)
7a6771
+		     / TYPE_LENGTH (TYPE_TARGET_TYPE (result)));
7a6771
       int elt_bitsize = TYPE_FIELD_BITSIZE (type0, 0);
7a6771
 
7a6771
       TYPE_FIELD_BITSIZE (result, 0) = TYPE_FIELD_BITSIZE (type0, 0);
7a6771
Index: gdb-7.11.50.20160716/gdb/ada-lang.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/ada-lang.h	2016-07-16 14:33:42.054510125 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/ada-lang.h	2016-07-16 14:33:44.528530036 +0200
7a6771
@@ -168,7 +168,7 @@
7a6771
 extern void ada_print_typedef (struct type *type, struct symbol *new_symbol,
7a6771
 			       struct ui_file *stream);
7a6771
 
7a6771
-extern void ada_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
7a6771
+extern void ada_val_print (struct type *, const gdb_byte *, LONGEST, CORE_ADDR,
7a6771
 			   struct ui_file *, int,
7a6771
 			   const struct value *,
7a6771
 			   const struct value_print_options *);
7a6771
@@ -183,7 +183,7 @@
7a6771
 extern void ada_printchar (int, struct type *, struct ui_file *);
7a6771
 
7a6771
 extern void ada_printstr (struct ui_file *, struct type *, const gdb_byte *,
7a6771
-			  unsigned int, const char *, int,
7a6771
+			  ULONGEST, const char *, int,
7a6771
 			  const struct value_print_options *);
7a6771
 
7a6771
 struct value *ada_convert_actual (struct value *actual,
7a6771
@@ -255,7 +255,7 @@
7a6771
 
7a6771
 extern struct value *ada_value_primitive_packed_val (struct value *,
7a6771
 						     const gdb_byte *,
7a6771
-                                                     long, int, int,
7a6771
+						     LONGEST, int, int,
7a6771
                                                      struct type *);
7a6771
 
7a6771
 extern struct type *ada_coerce_to_simple_array_type (struct type *);
7a6771
Index: gdb-7.11.50.20160716/gdb/ada-typeprint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/ada-typeprint.c	2016-07-16 14:33:42.055510133 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/ada-typeprint.c	2016-07-16 14:33:44.528530036 +0200
7a6771
@@ -891,8 +891,8 @@
7a6771
 	    const char *name = ada_type_name (type);
7a6771
 
7a6771
 	    if (!ada_is_range_type_name (name))
7a6771
-	      fprintf_filtered (stream, _("<%d-byte integer>"),
7a6771
-				TYPE_LENGTH (type));
7a6771
+	      fprintf_filtered (stream, _("<%s-byte integer>"),
7a6771
+				pulongest (TYPE_LENGTH (type)));
7a6771
 	    else
7a6771
 	      {
7a6771
 		fprintf_filtered (stream, "range ");
7a6771
@@ -913,7 +913,8 @@
7a6771
 	  }
7a6771
 	break;
7a6771
       case TYPE_CODE_FLT:
7a6771
-	fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
7a6771
+	fprintf_filtered (stream, _("<%s-byte float>"),
7a6771
+			  pulongest (TYPE_LENGTH (type)));
7a6771
 	break;
7a6771
       case TYPE_CODE_ENUM:
7a6771
 	if (show < 0)
7a6771
Index: gdb-7.11.50.20160716/gdb/ada-valprint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/ada-valprint.c	2016-07-16 14:33:42.056510141 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/ada-valprint.c	2016-07-16 14:33:44.528530036 +0200
7a6771
@@ -33,11 +33,11 @@
7a6771
 #include "objfiles.h"
7a6771
 
7a6771
 static int print_field_values (struct type *, const gdb_byte *,
7a6771
-			       int,
7a6771
+			       LONGEST,
7a6771
 			       struct ui_file *, int,
7a6771
 			       const struct value *,
7a6771
 			       const struct value_print_options *,
7a6771
-			       int, struct type *, int,
7a6771
+			       int, struct type *, LONGEST,
7a6771
 			       const struct language_defn *);
7a6771
 
7a6771
 
7a6771
@@ -279,7 +279,7 @@
7a6771
    of a character.  */
7a6771
 
7a6771
 static int
7a6771
-char_at (const gdb_byte *string, int i, int type_len,
7a6771
+char_at (const gdb_byte *string, LONGEST i, int type_len,
7a6771
 	 enum bfd_endian byte_order)
7a6771
 {
7a6771
   if (type_len == 1)
7a6771
@@ -441,11 +441,11 @@
7a6771
 
7a6771
 static void
7a6771
 printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,
7a6771
-	  unsigned int length, int force_ellipses, int type_len,
7a6771
+	  ULONGEST length, int force_ellipses, int type_len,
7a6771
 	  const struct value_print_options *options)
7a6771
 {
7a6771
   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (elttype));
7a6771
-  unsigned int i;
7a6771
+  ULONGEST i;
7a6771
   unsigned int things_printed = 0;
7a6771
   int in_quotes = 0;
7a6771
   int need_comma = 0;
7a6771
@@ -460,9 +460,9 @@
7a6771
     {
7a6771
       /* Position of the character we are examining
7a6771
          to see whether it is repeated.  */
7a6771
-      unsigned int rep1;
7a6771
+      ULONGEST rep1;
7a6771
       /* Number of repetitions we have detected so far.  */
7a6771
-      unsigned int reps;
7a6771
+      ULONGEST reps;
7a6771
 
7a6771
       QUIT;
7a6771
 
7a6771
@@ -493,7 +493,8 @@
7a6771
 	  ada_emit_char (char_at (string, i, type_len, byte_order),
7a6771
 			 elttype, stream, '\'', type_len);
7a6771
 	  fputs_filtered ("'", stream);
7a6771
-	  fprintf_filtered (stream, _(" <repeats %u times>"), reps);
7a6771
+	  fprintf_filtered (stream, _(" <repeats %s times>"),
7a6771
+			    pulongest (reps));
7a6771
 	  i = rep1 - 1;
7a6771
 	  things_printed += options->repeat_count_threshold;
7a6771
 	  need_comma = 1;
7a6771
@@ -521,7 +522,7 @@
7a6771
 
7a6771
 void
7a6771
 ada_printstr (struct ui_file *stream, struct type *type,
7a6771
-	      const gdb_byte *string, unsigned int length,
7a6771
+	      const gdb_byte *string, ULONGEST length,
7a6771
 	      const char *encoding, int force_ellipses,
7a6771
 	      const struct value_print_options *options)
7a6771
 {
7a6771
@@ -531,12 +532,12 @@
7a6771
 
7a6771
 static int
7a6771
 print_variant_part (struct type *type, int field_num,
7a6771
-		    const gdb_byte *valaddr, int offset,
7a6771
+		    const gdb_byte *valaddr, LONGEST offset,
7a6771
 		    struct ui_file *stream, int recurse,
7a6771
 		    const struct value *val,
7a6771
 		    const struct value_print_options *options,
7a6771
 		    int comma_needed,
7a6771
-		    struct type *outer_type, int outer_offset,
7a6771
+		    struct type *outer_type, LONGEST outer_offset,
7a6771
 		    const struct language_defn *language)
7a6771
 {
7a6771
   struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
7a6771
@@ -572,11 +573,11 @@
7a6771
 
7a6771
 static int
7a6771
 print_field_values (struct type *type, const gdb_byte *valaddr,
7a6771
-		    int offset, struct ui_file *stream, int recurse,
7a6771
+		    LONGEST offset, struct ui_file *stream, int recurse,
7a6771
 		    const struct value *val,
7a6771
 		    const struct value_print_options *options,
7a6771
 		    int comma_needed,
7a6771
-		    struct type *outer_type, int outer_offset,
7a6771
+		    struct type *outer_type, LONGEST outer_offset,
7a6771
 		    const struct language_defn *language)
7a6771
 {
7a6771
   int i, len;
7a6771
@@ -643,7 +644,7 @@
7a6771
 	    }
7a6771
 	  else
7a6771
 	    {
7a6771
-	      int bit_pos = TYPE_FIELD_BITPOS (type, i);
7a6771
+	      LONGEST bit_pos = TYPE_FIELD_BITPOS (type, i);
7a6771
 	      int bit_size = TYPE_FIELD_BITSIZE (type, i);
7a6771
 	      struct value_print_options opts;
7a6771
 
7a6771
@@ -689,8 +690,8 @@
7a6771
 {
7a6771
   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
7a6771
   struct type *elttype = TYPE_TARGET_TYPE (type);
7a6771
-  unsigned int eltlen;
7a6771
-  unsigned int len;
7a6771
+  ULONGEST eltlen;
7a6771
+  ULONGEST len;
7a6771
 
7a6771
   /* We know that ELTTYPE cannot possibly be null, because we assume
7a6771
      that we're called only when TYPE is a string-like type.
7a6771
@@ -709,7 +710,7 @@
7a6771
      elements up to it.  */
7a6771
   if (options->stop_print_at_null)
7a6771
     {
7a6771
-      int temp_len;
7a6771
+      LONGEST temp_len;
7a6771
 
7a6771
       /* Look for a NULL char.  */
7a6771
       for (temp_len = 0;
7a6771
@@ -1074,7 +1075,7 @@
7a6771
 
7a6771
 static void
7a6771
 ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
7a6771
-		 int offset, CORE_ADDR address,
7a6771
+		 LONGEST offset, CORE_ADDR address,
7a6771
 		 struct ui_file *stream, int recurse,
7a6771
 		 const struct value *original_value,
7a6771
 		 const struct value_print_options *options,
7a6771
@@ -1157,7 +1158,7 @@
7a6771
 
7a6771
 void
7a6771
 ada_val_print (struct type *type, const gdb_byte *valaddr,
7a6771
-	       int embedded_offset, CORE_ADDR address,
7a6771
+	       LONGEST embedded_offset, CORE_ADDR address,
7a6771
 	       struct ui_file *stream, int recurse,
7a6771
 	       const struct value *val,
7a6771
 	       const struct value_print_options *options)
7a6771
Index: gdb-7.11.50.20160716/gdb/annotate.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/annotate.c	2016-07-16 14:33:42.057510149 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/annotate.c	2016-07-16 14:33:44.528530036 +0200
7a6771
@@ -533,21 +533,21 @@
7a6771
 }
7a6771
 
7a6771
 void
7a6771
-annotate_array_section_begin (int idx, struct type *elttype)
7a6771
+annotate_array_section_begin (LONGEST idx, struct type *elttype)
7a6771
 {
7a6771
   if (annotation_level == 2)
7a6771
     {
7a6771
-      printf_filtered (("\n\032\032array-section-begin %d "), idx);
7a6771
+      printf_filtered (("\n\032\032array-section-begin %s "), plongest (idx));
7a6771
       print_value_flags (elttype);
7a6771
       printf_filtered (("\n"));
7a6771
     }
7a6771
 }
7a6771
 
7a6771
 void
7a6771
-annotate_elt_rep (unsigned int repcount)
7a6771
+annotate_elt_rep (ULONGEST repcount)
7a6771
 {
7a6771
   if (annotation_level == 2)
7a6771
-    printf_filtered (("\n\032\032elt-rep %u\n"), repcount);
7a6771
+    printf_filtered (("\n\032\032elt-rep %s\n"), pulongest (repcount));
7a6771
 }
7a6771
 
7a6771
 void
7a6771
Index: gdb-7.11.50.20160716/gdb/annotate.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/annotate.h	2016-07-16 14:33:42.057510149 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/annotate.h	2016-07-16 14:33:44.528530036 +0200
7a6771
@@ -92,8 +92,8 @@
7a6771
 extern void annotate_frame_where (void);
7a6771
 extern void annotate_frame_end (void);
7a6771
 
7a6771
-extern void annotate_array_section_begin (int, struct type *);
7a6771
-extern void annotate_elt_rep (unsigned int);
7a6771
+extern void annotate_array_section_begin (LONGEST, struct type *);
7a6771
+extern void annotate_elt_rep (ULONGEST);
7a6771
 extern void annotate_elt_rep_end (void);
7a6771
 extern void annotate_elt (void);
7a6771
 extern void annotate_array_section_end (void);
7a6771
Index: gdb-7.11.50.20160716/gdb/arm-linux-nat.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/arm-linux-nat.c	2016-07-16 14:33:42.057510149 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/arm-linux-nat.c	2016-07-16 14:33:44.529530044 +0200
7a6771
@@ -1063,7 +1063,7 @@
7a6771
    ADDR?  */
7a6771
 static int
7a6771
 arm_linux_region_ok_for_hw_watchpoint (struct target_ops *self,
7a6771
-				       CORE_ADDR addr, int len)
7a6771
+				       CORE_ADDR addr, LONGEST len)
7a6771
 {
7a6771
   const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
7a6771
   CORE_ADDR max_wp_length, aligned_addr;
7a6771
Index: gdb-7.11.50.20160716/gdb/ax-gdb.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/ax-gdb.c	2016-07-16 14:33:42.060510173 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/ax-gdb.c	2016-07-16 14:33:44.529530044 +0200
7a6771
@@ -83,12 +83,12 @@
7a6771
 static void gen_sign_extend (struct agent_expr *, struct type *);
7a6771
 static void gen_extend (struct agent_expr *, struct type *);
7a6771
 static void gen_fetch (struct agent_expr *, struct type *);
7a6771
-static void gen_left_shift (struct agent_expr *, int);
7a6771
+static void gen_left_shift (struct agent_expr *, LONGEST);
7a6771
 
7a6771
 
7a6771
 static void gen_frame_args_address (struct gdbarch *, struct agent_expr *);
7a6771
 static void gen_frame_locals_address (struct gdbarch *, struct agent_expr *);
7a6771
-static void gen_offset (struct agent_expr *ax, int offset);
7a6771
+static void gen_offset (struct agent_expr *ax, LONGEST offset);
7a6771
 static void gen_sym_offset (struct agent_expr *, struct symbol *);
7a6771
 static void gen_var_ref (struct gdbarch *, struct agent_expr *ax,
7a6771
 			 struct axs_value *value, struct symbol *var);
7a6771
@@ -136,15 +136,16 @@
7a6771
 static void gen_address_of (struct agent_expr *, struct axs_value *);
7a6771
 static void gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
7a6771
 			      struct axs_value *value,
7a6771
-			      struct type *type, int start, int end);
7a6771
+			      struct type *type, LONGEST start, LONGEST end);
7a6771
 static void gen_primitive_field (struct expression *exp,
7a6771
 				 struct agent_expr *ax,
7a6771
 				 struct axs_value *value,
7a6771
-				 int offset, int fieldno, struct type *type);
7a6771
+				 LONGEST offset, int fieldno,
7a6771
+				 struct type *type);
7a6771
 static int gen_struct_ref_recursive (struct expression *exp,
7a6771
 				     struct agent_expr *ax,
7a6771
 				     struct axs_value *value,
7a6771
-				     char *field, int offset,
7a6771
+				     char *field, LONGEST offset,
7a6771
 				     struct type *type);
7a6771
 static void gen_struct_ref (struct expression *exp, struct agent_expr *ax,
7a6771
 			    struct axs_value *value,
7a6771
@@ -538,7 +539,7 @@
7a6771
    right shift it by -DISTANCE bits if DISTANCE < 0.  This generates
7a6771
    unsigned (logical) right shifts.  */
7a6771
 static void
7a6771
-gen_left_shift (struct agent_expr *ax, int distance)
7a6771
+gen_left_shift (struct agent_expr *ax, LONGEST distance)
7a6771
 {
7a6771
   if (distance > 0)
7a6771
     {
7a6771
@@ -592,7 +593,7 @@
7a6771
    programming in ML, it would be clearer why these are the same
7a6771
    thing.  */
7a6771
 static void
7a6771
-gen_offset (struct agent_expr *ax, int offset)
7a6771
+gen_offset (struct agent_expr *ax, LONGEST offset)
7a6771
 {
7a6771
   /* It would suffice to simply push the offset and add it, but this
7a6771
      makes it easier to read positive and negative offsets in the
7a6771
@@ -1248,7 +1249,7 @@
7a6771
 static void
7a6771
 gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
7a6771
 		  struct axs_value *value, struct type *type,
7a6771
-		  int start, int end)
7a6771
+		  LONGEST start, LONGEST end)
7a6771
 {
7a6771
   /* Note that ops[i] fetches 8 << i bits.  */
7a6771
   static enum agent_op ops[]
7a6771
@@ -1283,13 +1284,13 @@
7a6771
 
7a6771
   /* The first and one-after-last bits in the field, but rounded down
7a6771
      and up to byte boundaries.  */
7a6771
-  int bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT;
7a6771
-  int bound_end = (((end + TARGET_CHAR_BIT - 1)
7a6771
-		    / TARGET_CHAR_BIT)
7a6771
-		   * TARGET_CHAR_BIT);
7a6771
+  LONGEST bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT;
7a6771
+  LONGEST bound_end = (((end + TARGET_CHAR_BIT - 1)
7a6771
+			/ TARGET_CHAR_BIT)
7a6771
+		       * TARGET_CHAR_BIT);
7a6771
 
7a6771
   /* current bit offset within the structure */
7a6771
-  int offset;
7a6771
+  LONGEST offset;
7a6771
 
7a6771
   /* The index in ops of the opcode we're considering.  */
7a6771
   int op;
7a6771
@@ -1408,7 +1409,7 @@
7a6771
 static void
7a6771
 gen_primitive_field (struct expression *exp,
7a6771
 		     struct agent_expr *ax, struct axs_value *value,
7a6771
-		     int offset, int fieldno, struct type *type)
7a6771
+		     LONGEST offset, int fieldno, struct type *type)
7a6771
 {
7a6771
   /* Is this a bitfield?  */
7a6771
   if (TYPE_FIELD_PACKED (type, fieldno))
7a6771
@@ -1433,7 +1434,7 @@
7a6771
 static int
7a6771
 gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
7a6771
 			  struct axs_value *value,
7a6771
-			  char *field, int offset, struct type *type)
7a6771
+			  char *field, LONGEST offset, struct type *type)
7a6771
 {
7a6771
   int i, rslt;
7a6771
   int nbases = TYPE_N_BASECLASSES (type);
7a6771
Index: gdb-7.11.50.20160716/gdb/ax-general.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/ax-general.c	2016-07-16 14:33:42.060510173 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/ax-general.c	2016-07-16 14:33:44.529530044 +0200
7a6771
@@ -199,7 +199,7 @@
7a6771
 
7a6771
 /* Append a trace_quick instruction to EXPR, to record N bytes.  */
7a6771
 void
7a6771
-ax_trace_quick (struct agent_expr *x, int n)
7a6771
+ax_trace_quick (struct agent_expr *x, LONGEST n)
7a6771
 {
7a6771
   /* N must fit in a byte.  */
7a6771
   if (n < 0 || n > 255)
7a6771
Index: gdb-7.11.50.20160716/gdb/ax.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/ax.h	2016-07-16 14:33:42.060510173 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/ax.h	2016-07-16 14:33:44.529530044 +0200
7a6771
@@ -210,7 +210,7 @@
7a6771
 extern void ax_zero_ext (struct agent_expr *EXPR, int N);
7a6771
 
7a6771
 /* Append a trace_quick instruction to EXPR, to record N bytes.  */
7a6771
-extern void ax_trace_quick (struct agent_expr *EXPR, int N);
7a6771
+extern void ax_trace_quick (struct agent_expr *EXPR, LONGEST N);
7a6771
 
7a6771
 /* Append a goto op to EXPR.  OP is the actual op (must be aop_goto or
7a6771
    aop_if_goto).  We assume we don't know the target offset yet,
7a6771
Index: gdb-7.11.50.20160716/gdb/breakpoint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/breakpoint.c	2016-07-16 14:33:42.067510230 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/breakpoint.c	2016-07-16 14:33:44.531530060 +0200
7a6771
@@ -2251,9 +2251,9 @@
7a6771
 	{
7a6771
 	  fprintf_unfiltered (gdb_stdlog,
7a6771
 			      "infrun: stepping past non-steppable watchpoint. "
7a6771
-			      "skipping watchpoint at %s:%d\n",
7a6771
+			      "skipping watchpoint at %s:%s\n",
7a6771
 			      paddress (bl->gdbarch, bl->address),
7a6771
-			      bl->length);
7a6771
+			      plongest (bl->length));
7a6771
 	}
7a6771
       return 0;
7a6771
     }
7a6771
@@ -7181,7 +7181,7 @@
7a6771
 
7a6771
 static int
7a6771
 breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
7a6771
-				int len1, struct address_space *aspace2,
7a6771
+				LONGEST len1, struct address_space *aspace2,
7a6771
 				CORE_ADDR addr2)
7a6771
 {
7a6771
   return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7a6771
@@ -11534,7 +11534,7 @@
7a6771
 		      && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
7a6771
 		{
7a6771
 		  CORE_ADDR vaddr = value_address (v);
7a6771
-		  int len;
7a6771
+		  LONGEST len;
7a6771
 		  int num_regs;
7a6771
 
7a6771
 		  len = (target_exact_watchpoints
7a6771
Index: gdb-7.11.50.20160716/gdb/breakpoint.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/breakpoint.h	2016-07-16 14:33:42.068510238 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/breakpoint.h	2016-07-16 14:33:44.532530068 +0200
7a6771
@@ -237,7 +237,7 @@
7a6771
 
7a6771
   /* If this is a ranged breakpoint, then this field contains the
7a6771
      length of the range that will be watched for execution.  */
7a6771
-  int length;
7a6771
+  LONGEST length;
7a6771
 
7a6771
   /* If the breakpoint lives in memory and reading that memory would
7a6771
      give back the breakpoint, instead of the original contents, then
7a6771
@@ -413,7 +413,7 @@
7a6771
   /* For hardware watchpoints, the size of the memory region being
7a6771
      watched.  For hardware ranged breakpoints, the size of the
7a6771
      breakpoint range.  */
7a6771
-  int length;
7a6771
+  LONGEST length;
7a6771
 
7a6771
   /* Type of hardware watchpoint.  */
7a6771
   enum target_hw_bp_type watchpoint_type;
7a6771
Index: gdb-7.11.50.20160716/gdb/c-lang.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/c-lang.c	2016-07-16 14:33:42.069510246 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/c-lang.c	2016-07-16 14:33:44.532530068 +0200
7a6771
@@ -186,7 +186,7 @@
7a6771
 
7a6771
 void
7a6771
 c_printstr (struct ui_file *stream, struct type *type, 
7a6771
-	    const gdb_byte *string, unsigned int length, 
7a6771
+	    const gdb_byte *string, ULONGEST length,
7a6771
 	    const char *user_encoding, int force_ellipses,
7a6771
 	    const struct value_print_options *options)
7a6771
 {
7a6771
@@ -675,7 +675,7 @@
7a6771
 	  }
7a6771
 	else
7a6771
 	  {
7a6771
-	    int i;
7a6771
+	    LONGEST i;
7a6771
 
7a6771
 	    /* Write the terminating character.  */
7a6771
 	    for (i = 0; i < TYPE_LENGTH (type); ++i)
7a6771
@@ -684,7 +684,7 @@
7a6771
 	    if (satisfy_expected)
7a6771
 	      {
7a6771
 		LONGEST low_bound, high_bound;
7a6771
-		int element_size = TYPE_LENGTH (type);
7a6771
+		LONGEST element_size = TYPE_LENGTH (type);
7a6771
 
7a6771
 		if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
7a6771
 					 &low_bound, &high_bound) < 0)
7a6771
Index: gdb-7.11.50.20160716/gdb/c-lang.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/c-lang.h	2016-07-16 14:33:42.069510246 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/c-lang.h	2016-07-16 14:33:44.532530068 +0200
7a6771
@@ -77,7 +77,7 @@
7a6771
 			     struct ui_file *);
7a6771
 
7a6771
 extern void c_val_print (struct type *, const gdb_byte *,
7a6771
-			 int, CORE_ADDR,
7a6771
+			 LONGEST, CORE_ADDR,
7a6771
 			 struct ui_file *, int,
7a6771
 			 const struct value *,
7a6771
 			 const struct value_print_options *);
7a6771
@@ -97,7 +97,7 @@
7a6771
 extern void c_printstr (struct ui_file * stream,
7a6771
 			struct type *elttype,
7a6771
 			const gdb_byte *string,
7a6771
-			unsigned int length,
7a6771
+			ULONGEST length,
7a6771
 			const char *user_encoding,
7a6771
 			int force_ellipses,
7a6771
 			const struct value_print_options *options);
7a6771
Index: gdb-7.11.50.20160716/gdb/c-valprint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/c-valprint.c	2016-07-16 14:33:42.070510254 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/c-valprint.c	2016-07-16 14:33:44.532530068 +0200
7a6771
@@ -244,7 +244,7 @@
7a6771
   if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
7a6771
     {
7a6771
       LONGEST low_bound, high_bound;
7a6771
-      int eltlen, len;
7a6771
+      LONGEST eltlen, len;
7a6771
       struct gdbarch *gdbarch = get_type_arch (type);
7a6771
       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
7a6771
       unsigned int i = 0;	/* Number of characters printed.  */
7a6771
@@ -318,8 +318,8 @@
7a6771
 	  if (cp_is_vtbl_ptr_type (elttype))
7a6771
 	    {
7a6771
 	      i = 1;
7a6771
-	      fprintf_filtered (stream, _("%d vtable entries"),
7a6771
-				len - 1);
7a6771
+	      fprintf_filtered (stream, _("%s vtable entries"),
7a6771
+				plongest (len - 1));
7a6771
 	    }
7a6771
 	  else
7a6771
 	    {
7a6771
@@ -396,7 +396,7 @@
7a6771
 	 -fvtable_thunks.  (Otherwise, look under
7a6771
 	 TYPE_CODE_PTR.)  */
7a6771
       struct gdbarch *gdbarch = get_type_arch (type);
7a6771
-      int offset = (embedded_offset
7a6771
+      LONGEST offset = (embedded_offset
7a6771
 		    + TYPE_FIELD_BITPOS (type,
7a6771
 					 VTBL_FNADDR_OFFSET) / 8);
7a6771
       struct type *field_type = TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET);
7a6771
@@ -495,7 +495,7 @@
7a6771
 
7a6771
 void
7a6771
 c_val_print (struct type *type, const gdb_byte *valaddr,
7a6771
-	     int embedded_offset, CORE_ADDR address,
7a6771
+	     LONGEST embedded_offset, CORE_ADDR address,
7a6771
 	     struct ui_file *stream, int recurse,
7a6771
 	     const struct value *original_value,
7a6771
 	     const struct value_print_options *options)
7a6771
Index: gdb-7.11.50.20160716/gdb/cp-abi.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/cp-abi.c	2016-07-16 14:33:42.070510254 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/cp-abi.c	2016-07-16 14:33:44.532530068 +0200
7a6771
@@ -64,12 +64,12 @@
7a6771
   return (*current_cp_abi.is_operator_name) (name);
7a6771
 }
7a6771
 
7a6771
-int
7a6771
+LONGEST
7a6771
 baseclass_offset (struct type *type, int index, const gdb_byte *valaddr,
7a6771
 		  LONGEST embedded_offset, CORE_ADDR address,
7a6771
 		  const struct value *val)
7a6771
 {
7a6771
-  int res = 0;
7a6771
+  LONGEST res = 0;
7a6771
 
7a6771
   gdb_assert (current_cp_abi.baseclass_offset != NULL);
7a6771
 
7a6771
@@ -96,7 +96,7 @@
7a6771
 struct value *
7a6771
 value_virtual_fn_field (struct value **arg1p,
7a6771
 			struct fn_field *f, int j,
7a6771
-			struct type *type, int offset)
7a6771
+			struct type *type, LONGEST offset)
7a6771
 {
7a6771
   if ((current_cp_abi.virtual_fn_field) == NULL)
7a6771
     return NULL;
7a6771
Index: gdb-7.11.50.20160716/gdb/cp-abi.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/cp-abi.h	2016-07-16 14:33:42.070510254 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/cp-abi.h	2016-07-16 14:33:44.532530068 +0200
7a6771
@@ -108,7 +108,7 @@
7a6771
 					     struct fn_field *f,
7a6771
 					     int j,
7a6771
 					     struct type *type,
7a6771
-					     int offset);
7a6771
+					     LONGEST offset);
7a6771
 
7a6771
 
7a6771
 /* Try to find the run-time type of VALUE, using C++ run-time type
7a6771
@@ -144,11 +144,11 @@
7a6771
    contents of VAL.  The result is the offset of the baseclass value
7a6771
    relative to (the address of)(ARG) + OFFSET.  */
7a6771
 
7a6771
-extern int baseclass_offset (struct type *type,
7a6771
-			     int index, const gdb_byte *valaddr,
7a6771
-			     LONGEST embedded_offset,
7a6771
-			     CORE_ADDR address,
7a6771
-			     const struct value *val);
7a6771
+extern LONGEST baseclass_offset (struct type *type,
7a6771
+				 int index, const gdb_byte *valaddr,
7a6771
+				 LONGEST embedded_offset,
7a6771
+				 CORE_ADDR address,
7a6771
+				 const struct value *val);
7a6771
 
7a6771
 /* Describe the target of a pointer to method.  CONTENTS is the byte
7a6771
    pattern representing the pointer to method.  TYPE is the pointer to
7a6771
@@ -227,12 +227,12 @@
7a6771
   struct value *(*virtual_fn_field) (struct value **arg1p,
7a6771
 				     struct fn_field * f,
7a6771
 				     int j, struct type * type,
7a6771
-				     int offset);
7a6771
+				     LONGEST offset);
7a6771
   struct type *(*rtti_type) (struct value *v, int *full,
7a6771
 			     LONGEST *top, int *using_enc);
7a6771
-  int (*baseclass_offset) (struct type *type, int index,
7a6771
-			   const bfd_byte *valaddr, LONGEST embedded_offset,
7a6771
-			   CORE_ADDR address, const struct value *val);
7a6771
+  LONGEST (*baseclass_offset) (struct type *type, int index,
7a6771
+			       const bfd_byte *valaddr, LONGEST embedded_offset,
7a6771
+			       CORE_ADDR address, const struct value *val);
7a6771
   void (*print_method_ptr) (const gdb_byte *contents,
7a6771
 			    struct type *type,
7a6771
 			    struct ui_file *stream);
7a6771
Index: gdb-7.11.50.20160716/gdb/cp-valprint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/cp-valprint.c	2016-07-16 14:33:42.071510262 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/cp-valprint.c	2016-07-16 14:33:44.532530068 +0200
7a6771
@@ -334,7 +334,7 @@
7a6771
 		}
7a6771
 	      else if (i == vptr_fieldno && type == vptr_basetype)
7a6771
 		{
7a6771
-		  int i_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
7a6771
+		  LONGEST i_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
7a6771
 		  struct type *i_type = TYPE_FIELD_TYPE (type, i);
7a6771
 
7a6771
 		  if (valprint_check_validity (stream, i_type, i_offset, val))
7a6771
Index: gdb-7.11.50.20160716/gdb/d-lang.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/d-lang.h	2016-07-16 14:33:42.071510262 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/d-lang.h	2016-07-16 14:33:44.533530076 +0200
7a6771
@@ -81,7 +81,7 @@
7a6771
 /* Defined in d-valprint.c  */
7a6771
 
7a6771
 extern void d_val_print (struct type *type, const gdb_byte *valaddr,
7a6771
-			 int embedded_offset, CORE_ADDR address,
7a6771
+			 LONGEST embedded_offset, CORE_ADDR address,
7a6771
 			 struct ui_file *stream, int recurse,
7a6771
 			 const struct value *val,
7a6771
 			 const struct value_print_options *options);
7a6771
Index: gdb-7.11.50.20160716/gdb/d-valprint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/d-valprint.c	2016-07-16 14:33:42.071510262 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/d-valprint.c	2016-07-16 14:33:44.533530076 +0200
7a6771
@@ -73,9 +73,9 @@
7a6771
 
7a6771
 /* Implements the la_val_print routine for language D.  */
7a6771
 void
7a6771
-d_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
7a6771
-             CORE_ADDR address, struct ui_file *stream, int recurse,
7a6771
-	     const struct value *val,
7a6771
+d_val_print (struct type *type, const gdb_byte *valaddr,
7a6771
+	     LONGEST embedded_offset, CORE_ADDR address,
7a6771
+	     struct ui_file *stream, int recurse, const struct value *val,
7a6771
              const struct value_print_options *options)
7a6771
 {
7a6771
   int ret;
7a6771
Index: gdb-7.11.50.20160716/gdb/doublest.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/doublest.c	2016-07-16 14:33:42.072510270 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/doublest.c	2016-07-16 14:33:44.533530076 +0200
7a6771
@@ -784,7 +784,7 @@
7a6771
    but not passed on by GDB.  This should be fixed.  */
7a6771
 
7a6771
 static const struct floatformat *
7a6771
-floatformat_from_length (struct gdbarch *gdbarch, int len)
7a6771
+floatformat_from_length (struct gdbarch *gdbarch, LONGEST len)
7a6771
 {
7a6771
   const struct floatformat *format;
7a6771
 
7a6771
@@ -812,8 +812,8 @@
7a6771
   else
7a6771
     format = NULL;
7a6771
   if (format == NULL)
7a6771
-    error (_("Unrecognized %d-bit floating-point type."),
7a6771
-	   len * TARGET_CHAR_BIT);
7a6771
+    error (_("Unrecognized %s-bit floating-point type."),
7a6771
+	   plongest (len * TARGET_CHAR_BIT));
7a6771
   return format;
7a6771
 }
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/dwarf2loc.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/dwarf2loc.c	2016-07-16 14:33:42.076510302 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/dwarf2loc.c	2016-07-16 14:33:44.533530076 +0200
7a6771
@@ -1638,19 +1638,19 @@
7a6771
    BITS_BIG_ENDIAN is taken directly from gdbarch.  */
7a6771
 
7a6771
 static void
7a6771
-copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
7a6771
-	      const gdb_byte *source, unsigned int source_offset_bits,
7a6771
-	      unsigned int bit_count,
7a6771
+copy_bitwise (gdb_byte *dest, ULONGEST dest_offset_bits,
7a6771
+	      const gdb_byte *source, ULONGEST source_offset,
7a6771
+	      ULONGEST bit_count,
7a6771
 	      int bits_big_endian)
7a6771
 {
7a6771
-  unsigned int dest_avail;
7a6771
+  unsigned int dest_avail, source_offset_bits;
7a6771
   int datum;
7a6771
 
7a6771
   /* Reduce everything to byte-size pieces.  */
7a6771
   dest += dest_offset_bits / 8;
7a6771
   dest_offset_bits %= 8;
7a6771
-  source += source_offset_bits / 8;
7a6771
-  source_offset_bits %= 8;
7a6771
+  source += source_offset / 8;
7a6771
+  source_offset_bits = source_offset % 8;
7a6771
 
7a6771
   dest_avail = 8 - dest_offset_bits % 8;
7a6771
 
7a6771
@@ -1688,13 +1688,13 @@
7a6771
 read_pieced_value (struct value *v)
7a6771
 {
7a6771
   int i;
7a6771
-  long offset = 0;
7a6771
+  LONGEST offset = 0;
7a6771
   ULONGEST bits_to_skip;
7a6771
   gdb_byte *contents;
7a6771
   struct piece_closure *c
7a6771
     = (struct piece_closure *) value_computed_closure (v);
7a6771
   struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
7a6771
-  size_t type_len;
7a6771
+  ULONGEST type_len;
7a6771
   size_t buffer_size = 0;
7a6771
   gdb_byte *buffer = NULL;
7a6771
   struct cleanup *cleanup;
7a6771
@@ -1721,8 +1721,8 @@
7a6771
   for (i = 0; i < c->n_pieces && offset < type_len; i++)
7a6771
     {
7a6771
       struct dwarf_expr_piece *p = &c->pieces[i];
7a6771
-      size_t this_size, this_size_bits;
7a6771
-      long dest_offset_bits, source_offset_bits, source_offset;
7a6771
+      ULONGEST this_size, this_size_bits;
7a6771
+      LONGEST dest_offset_bits, source_offset_bits, source_offset;
7a6771
       const gdb_byte *intermediate_buffer;
7a6771
 
7a6771
       /* Compute size, source, and destination offsets for copying, in
7a6771
@@ -1862,13 +1862,13 @@
7a6771
 write_pieced_value (struct value *to, struct value *from)
7a6771
 {
7a6771
   int i;
7a6771
-  long offset = 0;
7a6771
+  LONGEST offset = 0;
7a6771
   ULONGEST bits_to_skip;
7a6771
   const gdb_byte *contents;
7a6771
   struct piece_closure *c
7a6771
     = (struct piece_closure *) value_computed_closure (to);
7a6771
   struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
7a6771
-  size_t type_len;
7a6771
+  ULONGEST type_len;
7a6771
   size_t buffer_size = 0;
7a6771
   gdb_byte *buffer = NULL;
7a6771
   struct cleanup *cleanup;
7a6771
@@ -1896,8 +1896,8 @@
7a6771
   for (i = 0; i < c->n_pieces && offset < type_len; i++)
7a6771
     {
7a6771
       struct dwarf_expr_piece *p = &c->pieces[i];
7a6771
-      size_t this_size_bits, this_size;
7a6771
-      long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
7a6771
+      ULONGEST this_size_bits, this_size;
7a6771
+      LONGEST dest_offset_bits, source_offset_bits, dest_offset, source_offset;
7a6771
       int need_bitwise;
7a6771
       const gdb_byte *source_buffer;
7a6771
 
7a6771
@@ -2017,7 +2017,7 @@
7a6771
 
7a6771
 static int
7a6771
 check_pieced_synthetic_pointer (const struct value *value, LONGEST bit_offset,
7a6771
-				int bit_length)
7a6771
+				LONGEST bit_length)
7a6771
 {
7a6771
   struct piece_closure *c
7a6771
     = (struct piece_closure *) value_computed_closure (value);
7a6771
@@ -2030,7 +2030,7 @@
7a6771
   for (i = 0; i < c->n_pieces && bit_length > 0; i++)
7a6771
     {
7a6771
       struct dwarf_expr_piece *p = &c->pieces[i];
7a6771
-      size_t this_size_bits = p->size;
7a6771
+      ULONGEST this_size_bits = p->size;
7a6771
 
7a6771
       if (bit_offset > 0)
7a6771
 	{
7a6771
@@ -2132,8 +2132,8 @@
7a6771
   struct type *type;
7a6771
   struct frame_info *frame;
7a6771
   struct dwarf2_locexpr_baton baton;
7a6771
-  int i, bit_length;
7a6771
-  LONGEST bit_offset;
7a6771
+  int i;
7a6771
+  LONGEST bit_length, bit_offset;
7a6771
   struct dwarf_expr_piece *piece = NULL;
7a6771
   LONGEST byte_offset;
7a6771
   enum bfd_endian byte_order;
7a6771
@@ -2150,7 +2150,7 @@
7a6771
   for (i = 0; i < c->n_pieces && bit_length > 0; i++)
7a6771
     {
7a6771
       struct dwarf_expr_piece *p = &c->pieces[i];
7a6771
-      size_t this_size_bits = p->size;
7a6771
+      ULONGEST this_size_bits = p->size;
7a6771
 
7a6771
       if (bit_offset > 0)
7a6771
 	{
7a6771
@@ -2444,7 +2444,7 @@
7a6771
 	    struct value *value = dwarf_expr_fetch (ctx, 0);
7a6771
 	    gdb_byte *contents;
7a6771
 	    const gdb_byte *val_bytes;
7a6771
-	    size_t n = TYPE_LENGTH (value_type (value));
7a6771
+	    ULONGEST n = TYPE_LENGTH (value_type (value));
7a6771
 
7a6771
 	    if (byte_offset + TYPE_LENGTH (type) > n)
7a6771
 	      invalid_synthetic_pointer ();
7a6771
Index: gdb-7.11.50.20160716/gdb/dwarf2read.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/dwarf2read.c	2016-07-16 14:33:42.083510358 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/dwarf2read.c	2016-07-16 14:33:44.536530100 +0200
7a6771
@@ -1935,12 +1935,12 @@
7a6771
 }
7a6771
 
7a6771
 static void
7a6771
-dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
7a6771
-					      int arg3)
7a6771
+dwarf2_const_value_length_mismatch_complaint (const char *arg1, LONGEST arg2,
7a6771
+					      LONGEST arg3)
7a6771
 {
7a6771
   complaint (&symfile_complaints,
7a6771
-	     _("const value length mismatch for '%s', got %d, expected %d"),
7a6771
-	     arg1, arg2, arg3);
7a6771
+	     _("const value length mismatch for '%s', got %s, expected %s"),
7a6771
+	     arg1, plongest (arg2), plongest (arg3));
7a6771
 }
7a6771
 
7a6771
 static void
7a6771
@@ -12573,8 +12573,8 @@
7a6771
 	         object, and then subtract off the number of bits of
7a6771
 	         the field itself.  The result is the bit offset of
7a6771
 	         the LSB of the field.  */
7a6771
-	      int anonymous_size;
7a6771
-	      int bit_offset = DW_UNSND (attr);
7a6771
+	      LONGEST anonymous_size;
7a6771
+	      LONGEST bit_offset = DW_UNSND (attr);
7a6771
 
7a6771
 	      attr = dwarf2_attr (die, DW_AT_byte_size, cu);
7a6771
 	      if (attr)
7a6771
Index: gdb-7.11.50.20160716/gdb/eval.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/eval.c	2016-07-16 14:33:42.086510383 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/eval.c	2016-07-16 14:33:44.537530108 +0200
7a6771
@@ -317,7 +317,8 @@
7a6771
   while (--nargs >= 0)
7a6771
     {
7a6771
       struct value *val = NULL;
7a6771
-      int bitpos, bitsize;
7a6771
+      LONGEST bitpos;
7a6771
+      int bitsize;
7a6771
       bfd_byte *addr;
7a6771
 
7a6771
       fieldno++;
7a6771
@@ -378,7 +379,7 @@
7a6771
 		    enum noside noside, LONGEST low_bound, LONGEST high_bound)
7a6771
 {
7a6771
   LONGEST index;
7a6771
-  int element_size = TYPE_LENGTH (value_type (element));
7a6771
+  LONGEST element_size = TYPE_LENGTH (value_type (element));
7a6771
 
7a6771
   if (exp->elts[*pos].opcode == BINOP_COMMA)
7a6771
     {
7a6771
@@ -822,11 +823,11 @@
7a6771
     /* FIXME: Also mixed integral/booleans, with result an integer.  */
7a6771
     {
7a6771
       const struct builtin_type *builtin = builtin_type (gdbarch);
7a6771
-      unsigned int promoted_len1 = TYPE_LENGTH (type1);
7a6771
-      unsigned int promoted_len2 = TYPE_LENGTH (type2);
7a6771
+      ULONGEST promoted_len1 = TYPE_LENGTH (type1);
7a6771
+      ULONGEST promoted_len2 = TYPE_LENGTH (type2);
7a6771
       int is_unsigned1 = TYPE_UNSIGNED (type1);
7a6771
       int is_unsigned2 = TYPE_UNSIGNED (type2);
7a6771
-      unsigned int result_len;
7a6771
+      ULONGEST result_len;
7a6771
       int unsigned_operation;
7a6771
 
7a6771
       /* Determine type length and signedness after promotion for
7a6771
@@ -1008,7 +1009,7 @@
7a6771
   struct value **argvec;
7a6771
   int code;
7a6771
   int ix;
7a6771
-  long mem_offset;
7a6771
+  LONGEST mem_offset;
7a6771
   struct type **arg_types;
7a6771
   int save_pos1;
7a6771
   struct symbol *function = NULL;
7a6771
@@ -1187,7 +1188,7 @@
7a6771
 	  struct type *range_type = TYPE_INDEX_TYPE (type);
7a6771
 	  struct type *element_type = TYPE_TARGET_TYPE (type);
7a6771
 	  struct value *array = allocate_value (expect_type);
7a6771
-	  int element_size = TYPE_LENGTH (check_typedef (element_type));
7a6771
+	  LONGEST element_size = TYPE_LENGTH (check_typedef (element_type));
7a6771
 	  LONGEST low_bound, high_bound, index;
7a6771
 
7a6771
 	  if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
7a6771
Index: gdb-7.11.50.20160716/gdb/f-lang.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/f-lang.c	2016-07-16 14:33:42.087510391 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/f-lang.c	2016-07-16 14:33:44.537530108 +0200
7a6771
@@ -103,7 +103,7 @@
7a6771
 
7a6771
 static void
7a6771
 f_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
7a6771
-	    unsigned int length, const char *encoding, int force_ellipses,
7a6771
+	    ULONGEST length, const char *encoding, int force_ellipses,
7a6771
 	    const struct value_print_options *options)
7a6771
 {
7a6771
   const char *type_encoding = f_get_encoding (type);
7a6771
Index: gdb-7.11.50.20160716/gdb/f-lang.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/f-lang.h	2016-07-16 14:33:42.087510391 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/f-lang.h	2016-07-16 14:33:44.537530108 +0200
7a6771
@@ -30,7 +30,7 @@
7a6771
 extern void f_print_type (struct type *, const char *, struct ui_file *, int,
7a6771
 			  int, const struct type_print_options *);
7a6771
 
7a6771
-extern void f_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
7a6771
+extern void f_val_print (struct type *, const gdb_byte *, LONGEST, CORE_ADDR,
7a6771
 			 struct ui_file *, int,
7a6771
 			 const struct value *,
7a6771
 			 const struct value_print_options *);
7a6771
Index: gdb-7.11.50.20160716/gdb/f-valprint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/f-valprint.c	2016-07-16 14:33:42.087510391 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/f-valprint.c	2016-07-16 14:33:44.537530108 +0200
7a6771
@@ -38,7 +38,7 @@
7a6771
 static void info_common_command (char *, int);
7a6771
 static void f77_get_dynamic_length_of_aggregate (struct type *);
7a6771
 
7a6771
-int f77_array_offset_tbl[MAX_FORTRAN_DIMS + 1][2];
7a6771
+LONGEST f77_array_offset_tbl[MAX_FORTRAN_DIMS + 1][2];
7a6771
 
7a6771
 /* Array which holds offsets to be applied to get a row's elements
7a6771
    for a given array.  Array also holds the size of each subarray.  */
7a6771
@@ -73,8 +73,8 @@
7a6771
 static void
7a6771
 f77_get_dynamic_length_of_aggregate (struct type *type)
7a6771
 {
7a6771
-  int upper_bound = -1;
7a6771
-  int lower_bound = 1;
7a6771
+  LONGEST upper_bound = -1;
7a6771
+  LONGEST lower_bound = 1;
7a6771
 
7a6771
   /* Recursively go all the way down into a possibly multi-dimensional
7a6771
      F77 array and get the bounds.  For simple arrays, this is pretty
7a6771
@@ -106,7 +106,7 @@
7a6771
 static void
7a6771
 f77_print_array_1 (int nss, int ndimensions, struct type *type,
7a6771
 		   const gdb_byte *valaddr,
7a6771
-		   int embedded_offset, CORE_ADDR address,
7a6771
+		   LONGEST embedded_offset, CORE_ADDR address,
7a6771
 		   struct ui_file *stream, int recurse,
7a6771
 		   const struct value *val,
7a6771
 		   const struct value_print_options *options,
7a6771
@@ -115,7 +115,7 @@
7a6771
   struct type *range_type = TYPE_INDEX_TYPE (check_typedef (type));
7a6771
   CORE_ADDR addr = address + embedded_offset;
7a6771
   LONGEST lowerbound, upperbound;
7a6771
-  int i;
7a6771
+  LONGEST i;
7a6771
 
7a6771
   get_discrete_bounds (range_type, &lowerbound, &upperbound);
7a6771
 
7a6771
@@ -172,7 +172,7 @@
7a6771
 
7a6771
 static void
7a6771
 f77_print_array (struct type *type, const gdb_byte *valaddr,
7a6771
-		 int embedded_offset,
7a6771
+		 LONGEST embedded_offset,
7a6771
 		 CORE_ADDR address, struct ui_file *stream,
7a6771
 		 int recurse,
7a6771
 		 const struct value *val,
7a6771
@@ -211,8 +211,9 @@
7a6771
    function; they are identical.  */
7a6771
 
7a6771
 void
7a6771
-f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
7a6771
-	     CORE_ADDR address, struct ui_file *stream, int recurse,
7a6771
+f_val_print (struct type *type, const gdb_byte *valaddr,
7a6771
+	     LONGEST embedded_offset, CORE_ADDR address,
7a6771
+	     struct ui_file *stream, int recurse,
7a6771
 	     const struct value *original_value,
7a6771
 	     const struct value_print_options *options)
7a6771
 {
7a6771
Index: gdb-7.11.50.20160716/gdb/findvar.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/findvar.c	2016-07-16 14:33:42.088510399 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/findvar.c	2016-07-16 14:33:44.537530108 +0200
7a6771
@@ -802,7 +802,7 @@
7a6771
 default_value_from_register (struct gdbarch *gdbarch, struct type *type,
7a6771
                              int regnum, struct frame_id frame_id)
7a6771
 {
7a6771
-  int len = TYPE_LENGTH (type);
7a6771
+  LONGEST len = TYPE_LENGTH (type);
7a6771
   struct value *value = allocate_value (type);
7a6771
 
7a6771
   VALUE_LVAL (value) = lval_register;
7a6771
@@ -838,7 +838,7 @@
7a6771
   LONGEST offset = 0;
7a6771
   LONGEST reg_offset = value_offset (value);
7a6771
   int regnum = VALUE_REGNUM (value);
7a6771
-  int len = type_length_units (check_typedef (value_type (value)));
7a6771
+  LONGEST len = type_length_units (check_typedef (value_type (value)));
7a6771
 
7a6771
   gdb_assert (VALUE_LVAL (value) == lval_register);
7a6771
 
7a6771
@@ -853,7 +853,7 @@
7a6771
   while (len > 0)
7a6771
     {
7a6771
       struct value *regval = get_frame_register_value (frame, regnum);
7a6771
-      int reg_len = type_length_units (value_type (regval)) - reg_offset;
7a6771
+      LONGEST reg_len = type_length_units (value_type (regval)) - reg_offset;
7a6771
 
7a6771
       /* If the register length is larger than the number of bytes
7a6771
          remaining to copy, then only copy the appropriate bytes.  */
7a6771
Index: gdb-7.11.50.20160716/gdb/frame.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/frame.c	2016-07-16 14:33:42.089510407 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/frame.c	2016-07-16 14:33:44.538530116 +0200
7a6771
@@ -1320,7 +1320,7 @@
7a6771
 
7a6771
 int
7a6771
 get_frame_register_bytes (struct frame_info *frame, int regnum,
7a6771
-			  CORE_ADDR offset, int len, gdb_byte *myaddr,
7a6771
+			  CORE_ADDR offset, LONGEST len, gdb_byte *myaddr,
7a6771
 			  int *optimizedp, int *unavailablep)
7a6771
 {
7a6771
   struct gdbarch *gdbarch = get_frame_arch (frame);
7a6771
@@ -1349,7 +1349,7 @@
7a6771
     }
7a6771
   if (len > maxsize)
7a6771
     error (_("Bad debug information detected: "
7a6771
-	     "Attempt to read %d bytes from registers."), len);
7a6771
+	     "Attempt to read %s bytes from registers."), plongest (len));
7a6771
 
7a6771
   /* Copy the data.  */
7a6771
   while (len > 0)
7a6771
Index: gdb-7.11.50.20160716/gdb/frame.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/frame.h	2016-07-16 14:33:42.090510415 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/frame.h	2016-07-16 14:33:44.538530116 +0200
7a6771
@@ -585,7 +585,7 @@
7a6771
    contents are optimized out or unavailable, set *OPTIMIZEDP,
7a6771
    *UNAVAILABLEP accordingly.  */
7a6771
 extern int get_frame_register_bytes (struct frame_info *frame, int regnum,
7a6771
-				     CORE_ADDR offset, int len,
7a6771
+				     CORE_ADDR offset, LONGEST len,
7a6771
 				     gdb_byte *myaddr,
7a6771
 				     int *optimizedp, int *unavailablep);
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/gdbtypes.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/gdbtypes.c	2016-07-16 14:33:42.092510431 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/gdbtypes.c	2016-07-16 14:33:44.539530124 +0200
7a6771
@@ -2722,7 +2722,7 @@
7a6771
    least as long as OBJFILE.  */
7a6771
 
7a6771
 struct type *
7a6771
-init_type (enum type_code code, int length, int flags,
7a6771
+init_type (enum type_code code, LONGEST length, int flags,
7a6771
 	   const char *name, struct objfile *objfile)
7a6771
 {
7a6771
   struct type *type;
7a6771
@@ -2962,8 +2962,8 @@
7a6771
 
7a6771
 static int
7a6771
 is_unique_ancestor_worker (struct type *base, struct type *dclass,
7a6771
-			   int *offset,
7a6771
-			   const gdb_byte *valaddr, int embedded_offset,
7a6771
+			   LONGEST *offset,
7a6771
+			   const gdb_byte *valaddr, LONGEST embedded_offset,
7a6771
 			   CORE_ADDR address, struct value *val)
7a6771
 {
7a6771
   int i, count = 0;
7a6771
@@ -2974,7 +2974,7 @@
7a6771
   for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
7a6771
     {
7a6771
       struct type *iter;
7a6771
-      int this_offset;
7a6771
+      LONGEST this_offset;
7a6771
 
7a6771
       iter = check_typedef (TYPE_BASECLASS (dclass, i));
7a6771
 
7a6771
@@ -3015,7 +3015,7 @@
7a6771
 int
7a6771
 is_unique_ancestor (struct type *base, struct value *val)
7a6771
 {
7a6771
-  int offset = -1;
7a6771
+  LONGEST offset = -1;
7a6771
 
7a6771
   return is_unique_ancestor_worker (base, value_type (val), &offset,
7a6771
 				    value_contents_for_printing (val),
7a6771
@@ -4203,7 +4203,7 @@
7a6771
       break;
7a6771
     }
7a6771
   puts_filtered ("\n");
7a6771
-  printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
7a6771
+  printfi_filtered (spaces, "length %s\n", pulongest (TYPE_LENGTH (type)));
7a6771
   if (TYPE_OBJFILE_OWNED (type))
7a6771
     {
7a6771
       printfi_filtered (spaces, "objfile ");
7a6771
@@ -4663,7 +4663,7 @@
7a6771
 
7a6771
 struct type *
7a6771
 arch_type (struct gdbarch *gdbarch,
7a6771
-	   enum type_code code, int length, const char *name)
7a6771
+	   enum type_code code, LONGEST length, const char *name)
7a6771
 {
7a6771
   struct type *type;
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/gdbtypes.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/gdbtypes.h	2016-07-16 14:33:42.093510439 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/gdbtypes.h	2016-07-16 14:33:44.539530124 +0200
7a6771
@@ -806,7 +806,7 @@
7a6771
      type_length_units function should be used in order to get the length
7a6771
      expressed in target addressable memory units.  */
7a6771
 
7a6771
-  unsigned int length;
7a6771
+  ULONGEST length;
7a6771
 
7a6771
   /* * Core type, shared by a group of qualified types.  */
7a6771
 
7a6771
@@ -1677,11 +1677,11 @@
7a6771
 
7a6771
 /* * Helper function to construct objfile-owned types.  */
7a6771
 
7a6771
-extern struct type *init_type (enum type_code, int, int, const char *,
7a6771
+extern struct type *init_type (enum type_code, LONGEST, int, const char *,
7a6771
 			       struct objfile *);
7a6771
 
7a6771
 /* Helper functions to construct architecture-owned types.  */
7a6771
-extern struct type *arch_type (struct gdbarch *, enum type_code, int,
7a6771
+extern struct type *arch_type (struct gdbarch *, enum type_code, LONGEST,
7a6771
 			       const char *);
7a6771
 extern struct type *arch_integer_type (struct gdbarch *, int, int,
7a6771
 				       const char *);
7a6771
Index: gdb-7.11.50.20160716/gdb/gnu-v2-abi.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/gnu-v2-abi.c	2016-07-16 14:33:42.093510439 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/gnu-v2-abi.c	2016-07-16 14:33:44.539530124 +0200
7a6771
@@ -82,7 +82,7 @@
7a6771
    TYPE is the type in which F is located.  */
7a6771
 static struct value *
7a6771
 gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
7a6771
-			struct type * type, int offset)
7a6771
+			struct type *type, LONGEST offset)
7a6771
 {
7a6771
   struct value *arg1 = *arg1p;
7a6771
   struct type *type1 = check_typedef (value_type (arg1));
7a6771
@@ -338,7 +338,7 @@
7a6771
    target).  The result is the offset of the baseclass value relative
7a6771
    to (the address of)(ARG) + OFFSET.  */
7a6771
 
7a6771
-static int
7a6771
+static LONGEST
7a6771
 gnuv2_baseclass_offset (struct type *type, int index,
7a6771
 			const bfd_byte *valaddr, LONGEST embedded_offset,
7a6771
 			CORE_ADDR address, const struct value *val)
7a6771
@@ -358,8 +358,7 @@
7a6771
 	  if (vb_match (type, i, basetype))
7a6771
 	    {
7a6771
 	      struct type *field_type;
7a6771
-	      LONGEST field_offset;
7a6771
-	      int field_length;
7a6771
+	      LONGEST field_offset, field_length;
7a6771
 	      CORE_ADDR addr;
7a6771
 
7a6771
 	      field_type = check_typedef (TYPE_FIELD_TYPE (type, i));
7a6771
@@ -383,7 +382,7 @@
7a6771
 	  /* Don't go through baseclass_offset, as that wraps
7a6771
 	     exceptions, thus, inner exceptions would be wrapped more
7a6771
 	     than once.  */
7a6771
-	  int boffset =
7a6771
+	  LONGEST boffset =
7a6771
 	    gnuv2_baseclass_offset (type, i, valaddr,
7a6771
 				    embedded_offset, address, val);
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/gnu-v3-abi.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/gnu-v3-abi.c	2016-07-16 14:33:42.094510447 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/gnu-v3-abi.c	2016-07-16 14:33:44.539530124 +0200
7a6771
@@ -108,7 +108,7 @@
7a6771
 {
7a6771
   struct type *t;
7a6771
   struct field *field_list, *field;
7a6771
-  int offset;
7a6771
+  LONGEST offset;
7a6771
 
7a6771
   struct type *void_ptr_type
7a6771
     = builtin_type (arch)->builtin_data_ptr;
7a6771
@@ -184,7 +184,7 @@
7a6771
 /* Return the offset from the start of the imaginary `struct
7a6771
    gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
7a6771
    (i.e., where objects' virtual table pointers point).  */
7a6771
-static int
7a6771
+static LONGEST
7a6771
 vtable_address_point_offset (struct gdbarch *gdbarch)
7a6771
 {
7a6771
   struct type *vtable_type
7a6771
@@ -411,7 +411,7 @@
7a6771
 static struct value *
7a6771
 gnuv3_virtual_fn_field (struct value **value_p,
7a6771
                         struct fn_field *f, int j,
7a6771
-			struct type *vfn_base, int offset)
7a6771
+			struct type *vfn_base, LONGEST offset)
7a6771
 {
7a6771
   struct type *values_type = check_typedef (value_type (*value_p));
7a6771
   struct gdbarch *gdbarch;
7a6771
@@ -441,7 +441,7 @@
7a6771
 
7a6771
    -1 is returned on error.  */
7a6771
 
7a6771
-static int
7a6771
+static LONGEST
7a6771
 gnuv3_baseclass_offset (struct type *type, int index,
7a6771
 			const bfd_byte *valaddr, LONGEST embedded_offset,
7a6771
 			CORE_ADDR address, const struct value *val)
7a6771
@@ -450,7 +450,7 @@
7a6771
   struct type *ptr_type;
7a6771
   struct value *vtable;
7a6771
   struct value *vbase_array;
7a6771
-  long int cur_base_offset, base_offset;
7a6771
+  LONGEST cur_base_offset, base_offset;
7a6771
 
7a6771
   /* Determine architecture.  */
7a6771
   gdbarch = get_type_arch (type);
7a6771
@@ -474,7 +474,7 @@
7a6771
   cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch);
7a6771
   if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0)
7a6771
     error (_("Misaligned vbase offset."));
7a6771
-  cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type));
7a6771
+  cur_base_offset = cur_base_offset / ((LONGEST) TYPE_LENGTH (ptr_type));
7a6771
 
7a6771
   vtable = gnuv3_get_vtable (gdbarch, type, address + embedded_offset);
7a6771
   gdb_assert (vtable != NULL);
7a6771
@@ -518,7 +518,7 @@
7a6771
      we're out of luck.  */
7a6771
   for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
7a6771
     {
7a6771
-      int pos;
7a6771
+      LONGEST pos;
7a6771
       struct type *basetype;
7a6771
 
7a6771
       if (BASETYPE_VIA_VIRTUAL (domain, i))
7a6771
Index: gdb-7.11.50.20160716/gdb/go-lang.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/go-lang.h	2016-07-16 14:33:42.094510447 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/go-lang.h	2016-07-16 14:33:44.539530124 +0200
7a6771
@@ -85,7 +85,7 @@
7a6771
 /* Defined in go-valprint.c.  */
7a6771
 
7a6771
 extern void go_val_print (struct type *type, const gdb_byte *valaddr,
7a6771
-			  int embedded_offset, CORE_ADDR address,
7a6771
+			  LONGEST embedded_offset, CORE_ADDR address,
7a6771
 			  struct ui_file *stream, int recurse,
7a6771
 			  const struct value *val,
7a6771
 			  const struct value_print_options *options);
7a6771
Index: gdb-7.11.50.20160716/gdb/go-valprint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/go-valprint.c	2016-07-16 14:33:42.094510447 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/go-valprint.c	2016-07-16 14:33:44.539530124 +0200
7a6771
@@ -86,9 +86,9 @@
7a6771
 /* Implements the la_val_print routine for language Go.  */
7a6771
 
7a6771
 void
7a6771
-go_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
7a6771
-	      CORE_ADDR address, struct ui_file *stream, int recurse,
7a6771
-	      const struct value *val,
7a6771
+go_val_print (struct type *type, const gdb_byte *valaddr,
7a6771
+	      LONGEST embedded_offset, CORE_ADDR address,
7a6771
+	      struct ui_file *stream, int recurse, const struct value *val,
7a6771
 	      const struct value_print_options *options)
7a6771
 {
7a6771
   type = check_typedef (type);
7a6771
Index: gdb-7.11.50.20160716/gdb/jv-lang.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/jv-lang.c	2016-07-16 14:33:42.094510447 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/jv-lang.c	2016-07-16 14:33:44.540530132 +0200
7a6771
@@ -440,7 +440,7 @@
7a6771
   for (i = TYPE_N_BASECLASSES (type); i < nfields; i++)
7a6771
     {
7a6771
       int accflags;
7a6771
-      int boffset;
7a6771
+      LONGEST boffset;
7a6771
 
7a6771
       if (fields == NULL)
7a6771
 	{
7a6771
@@ -890,7 +890,7 @@
7a6771
 static void
7a6771
 java_printstr (struct ui_file *stream, struct type *type,
7a6771
 	       const gdb_byte *string,
7a6771
-	       unsigned int length, const char *encoding, int force_ellipses,
7a6771
+	       ULONGEST length, const char *encoding, int force_ellipses,
7a6771
 	       const struct value_print_options *options)
7a6771
 {
7a6771
   const char *type_encoding = java_get_encoding (type);
7a6771
Index: gdb-7.11.50.20160716/gdb/jv-lang.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/jv-lang.h	2016-07-16 14:33:42.094510447 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/jv-lang.h	2016-07-16 14:33:44.540530132 +0200
7a6771
@@ -43,8 +43,8 @@
7a6771
 
7a6771
 extern const struct builtin_java_type *builtin_java_type (struct gdbarch *);
7a6771
 
7a6771
-extern void java_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
7a6771
-			    struct ui_file *, int,
7a6771
+extern void java_val_print (struct type *, const gdb_byte *, LONGEST,
7a6771
+			    CORE_ADDR, struct ui_file *, int,
7a6771
 			    const struct value *,
7a6771
 			    const struct value_print_options *);
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/jv-valprint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/jv-valprint.c	2016-07-16 14:33:42.095510455 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/jv-valprint.c	2016-07-16 14:33:44.540530132 +0200
7a6771
@@ -454,7 +454,7 @@
7a6771
 
7a6771
 void
7a6771
 java_val_print (struct type *type, const gdb_byte *valaddr,
7a6771
-		int embedded_offset, CORE_ADDR address,
7a6771
+		LONGEST embedded_offset, CORE_ADDR address,
7a6771
 		struct ui_file *stream, int recurse,
7a6771
 		const struct value *val,
7a6771
 		const struct value_print_options *options)
7a6771
Index: gdb-7.11.50.20160716/gdb/language.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/language.c	2016-07-16 14:33:42.095510455 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/language.c	2016-07-16 14:33:44.540530132 +0200
7a6771
@@ -766,7 +766,7 @@
7a6771
 
7a6771
 static void
7a6771
 unk_lang_printstr (struct ui_file *stream, struct type *type,
7a6771
-		   const gdb_byte *string, unsigned int length,
7a6771
+		   const gdb_byte *string, ULONGEST length,
7a6771
 		   const char *encoding, int force_ellipses,
7a6771
 		   const struct value_print_options *options)
7a6771
 {
7a6771
@@ -785,7 +785,7 @@
7a6771
 
7a6771
 static void
7a6771
 unk_lang_val_print (struct type *type, const gdb_byte *valaddr,
7a6771
-		    int embedded_offset, CORE_ADDR address,
7a6771
+		    LONGEST embedded_offset, CORE_ADDR address,
7a6771
 		    struct ui_file *stream, int recurse,
7a6771
 		    const struct value *val,
7a6771
 		    const struct value_print_options *options)
7a6771
Index: gdb-7.11.50.20160716/gdb/language.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/language.h	2016-07-16 14:33:42.095510455 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/language.h	2016-07-16 14:33:44.540530132 +0200
7a6771
@@ -196,7 +196,7 @@
7a6771
 			  struct ui_file * stream);
7a6771
 
7a6771
     void (*la_printstr) (struct ui_file * stream, struct type *elttype,
7a6771
-			 const gdb_byte *string, unsigned int length,
7a6771
+			 const gdb_byte *string, ULONGEST length,
7a6771
 			 const char *encoding, int force_ellipses,
7a6771
 			 const struct value_print_options *);
7a6771
 
7a6771
@@ -238,7 +238,7 @@
7a6771
 
7a6771
     void (*la_val_print) (struct type *type,
7a6771
 			  const gdb_byte *contents,
7a6771
-			  int embedded_offset, CORE_ADDR address,
7a6771
+			  LONGEST embedded_offset, CORE_ADDR address,
7a6771
 			  struct ui_file *stream, int recurse,
7a6771
 			  const struct value *val,
7a6771
 			  const struct value_print_options *options);
7a6771
Index: gdb-7.11.50.20160716/gdb/m2-lang.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/m2-lang.c	2016-07-16 14:33:42.096510463 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/m2-lang.c	2016-07-16 14:33:44.540530132 +0200
7a6771
@@ -104,10 +104,10 @@
7a6771
 
7a6771
 static void
7a6771
 m2_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
7a6771
-	     unsigned int length, const char *encoding, int force_ellipses,
7a6771
+	     ULONGEST length, const char *encoding, int force_ellipses,
7a6771
 	     const struct value_print_options *options)
7a6771
 {
7a6771
-  unsigned int i;
7a6771
+  ULONGEST i;
7a6771
   unsigned int things_printed = 0;
7a6771
   int in_quotes = 0;
7a6771
   int need_comma = 0;
7a6771
@@ -122,9 +122,9 @@
7a6771
     {
7a6771
       /* Position of the character we are examining
7a6771
          to see whether it is repeated.  */
7a6771
-      unsigned int rep1;
7a6771
+      ULONGEST rep1;
7a6771
       /* Number of repetitions we have detected so far.  */
7a6771
-      unsigned int reps;
7a6771
+      ULONGEST reps;
7a6771
 
7a6771
       QUIT;
7a6771
 
7a6771
@@ -150,7 +150,7 @@
7a6771
 	      in_quotes = 0;
7a6771
 	    }
7a6771
 	  m2_printchar (string[i], type, stream);
7a6771
-	  fprintf_filtered (stream, " <repeats %u times>", reps);
7a6771
+	  fprintf_filtered (stream, " <repeats %s times>", pulongest (reps));
7a6771
 	  i = rep1 - 1;
7a6771
 	  things_printed += options->repeat_count_threshold;
7a6771
 	  need_comma = 1;
7a6771
Index: gdb-7.11.50.20160716/gdb/m2-lang.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/m2-lang.h	2016-07-16 14:33:42.096510463 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/m2-lang.h	2016-07-16 14:33:44.540530132 +0200
7a6771
@@ -34,7 +34,7 @@
7a6771
 extern int m2_is_long_set (struct type *type);
7a6771
 extern int m2_is_unbounded_array (struct type *type);
7a6771
 
7a6771
-extern void m2_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
7a6771
+extern void m2_val_print (struct type *, const gdb_byte *, LONGEST, CORE_ADDR,
7a6771
 			  struct ui_file *, int,
7a6771
 			  const struct value *,
7a6771
 			  const struct value_print_options *);
7a6771
Index: gdb-7.11.50.20160716/gdb/m2-typeprint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/m2-typeprint.c	2016-07-16 14:33:42.096510463 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/m2-typeprint.c	2016-07-16 14:33:44.541530140 +0200
7a6771
@@ -234,9 +234,12 @@
7a6771
 	  m2_print_bounds (TYPE_INDEX_TYPE (type), stream, show, -1, 1);
7a6771
 	}
7a6771
       else
7a6771
-	fprintf_filtered (stream, "%d",
7a6771
-			  (TYPE_LENGTH (type)
7a6771
-			   / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
7a6771
+        {
7a6771
+	  ULONGEST val = (TYPE_LENGTH (type)
7a6771
+			  / TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
7a6771
+
7a6771
+	  fprintf_filtered (stream, "%s", pulongest (val));
7a6771
+	}
7a6771
     }
7a6771
   fprintf_filtered (stream, "] OF ");
7a6771
   m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
7a6771
Index: gdb-7.11.50.20160716/gdb/m2-valprint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/m2-valprint.c	2016-07-16 14:33:42.096510463 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/m2-valprint.c	2016-07-16 14:35:19.830297013 +0200
7a6771
@@ -35,7 +35,7 @@
7a6771
 				   struct ui_file *stream);
7a6771
 static void
7a6771
 m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
7a6771
-			 int embedded_offset, CORE_ADDR address,
7a6771
+			 LONGEST embedded_offset, CORE_ADDR address,
7a6771
 			 struct ui_file *stream, int recurse,
7a6771
 			 const struct value *val,
7a6771
 			 const struct value_print_options *options,
7a6771
@@ -67,7 +67,7 @@
7a6771
 
7a6771
 static void
7a6771
 m2_print_long_set (struct type *type, const gdb_byte *valaddr,
7a6771
-		   int embedded_offset, CORE_ADDR address,
7a6771
+		   LONGEST embedded_offset, CORE_ADDR address,
7a6771
 		   struct ui_file *stream)
7a6771
 {
7a6771
   int empty_set        = 1;
7a6771
@@ -158,7 +158,7 @@
7a6771
 
7a6771
 static void
7a6771
 m2_print_unbounded_array (struct type *type, const gdb_byte *valaddr,
7a6771
-			  int embedded_offset, CORE_ADDR address,
7a6771
+			  LONGEST embedded_offset, CORE_ADDR address,
7a6771
 			  struct ui_file *stream, int recurse,
7a6771
 			  const struct value_print_options *options)
7a6771
 {
7a6771
@@ -260,7 +260,7 @@
7a6771
 
7a6771
 static void
7a6771
 m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
7a6771
-			 int embedded_offset, CORE_ADDR address,
7a6771
+			 LONGEST embedded_offset, CORE_ADDR address,
7a6771
 			 struct ui_file *stream, int recurse,
7a6771
 			 const struct value *val,
7a6771
 			 const struct value_print_options *options,
7a6771
@@ -308,13 +308,13 @@
7a6771
    function; they are identical.  */
7a6771
 
7a6771
 void
7a6771
-m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
7a6771
+m2_val_print (struct type *type, const gdb_byte *valaddr, LONGEST embedded_offset,
7a6771
 	      CORE_ADDR address, struct ui_file *stream, int recurse,
7a6771
 	      const struct value *original_value,
7a6771
 	      const struct value_print_options *options)
7a6771
 {
7a6771
   struct gdbarch *gdbarch = get_type_arch (type);
7a6771
-  unsigned len;
7a6771
+  ULONGEST len;
7a6771
   struct type *elttype;
7a6771
   CORE_ADDR addr;
7a6771
 
7a6771
@@ -339,7 +339,7 @@
7a6771
 	         elements up to it.  */
7a6771
 	      if (options->stop_print_at_null)
7a6771
 		{
7a6771
-		  unsigned int temp_len;
7a6771
+		  ULONGEST temp_len;
7a6771
 
7a6771
 		  /* Look for a NULL char.  */
7a6771
 		  for (temp_len = 0;
7a6771
@@ -415,7 +415,7 @@
7a6771
 	{
7a6771
 	  struct type *range = elttype;
7a6771
 	  LONGEST low_bound, high_bound;
7a6771
-	  int i;
7a6771
+	  LONGEST i;
7a6771
 	  int need_comma = 0;
7a6771
 
7a6771
 	  fputs_filtered ("{", stream);
7a6771
Index: gdb-7.11.50.20160716/gdb/memrange.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/memrange.c	2016-07-16 14:33:42.096510463 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/memrange.c	2016-07-16 14:33:44.541530140 +0200
7a6771
@@ -21,8 +21,8 @@
7a6771
 #include "memrange.h"
7a6771
 
7a6771
 int
7a6771
-mem_ranges_overlap (CORE_ADDR start1, int len1,
7a6771
-		    CORE_ADDR start2, int len2)
7a6771
+mem_ranges_overlap (CORE_ADDR start1, LONGEST len1,
7a6771
+		    CORE_ADDR start2, LONGEST len2)
7a6771
 {
7a6771
   ULONGEST h, l;
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/memrange.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/memrange.h	2016-07-16 14:33:42.097510471 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/memrange.h	2016-07-16 14:33:44.541530140 +0200
7a6771
@@ -30,7 +30,7 @@
7a6771
   CORE_ADDR start;
7a6771
 
7a6771
   /* Length of the range.  */
7a6771
-  int length;
7a6771
+  LONGEST length;
7a6771
 };
7a6771
 
7a6771
 typedef struct mem_range mem_range_s;
7a6771
@@ -40,8 +40,8 @@
7a6771
 /* Returns true if the ranges defined by [start1, start1+len1) and
7a6771
    [start2, start2+len2) overlap.  */
7a6771
 
7a6771
-extern int mem_ranges_overlap (CORE_ADDR start1, int len1,
7a6771
-			       CORE_ADDR start2, int len2);
7a6771
+extern int mem_ranges_overlap (CORE_ADDR start1, LONGEST len1,
7a6771
+			       CORE_ADDR start2, LONGEST len2);
7a6771
 
7a6771
 /* Returns true if ADDR is in RANGE.  */
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/mips-linux-nat.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/mips-linux-nat.c	2016-07-16 14:33:42.097510471 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/mips-linux-nat.c	2016-07-16 14:33:44.541530140 +0200
7a6771
@@ -587,7 +587,7 @@
7a6771
 
7a6771
 static int
7a6771
 mips_linux_region_ok_for_hw_watchpoint (struct target_ops *self,
7a6771
-					CORE_ADDR addr, int len)
7a6771
+					CORE_ADDR addr, LONGEST len)
7a6771
 {
7a6771
   struct pt_watch_regs dummy_regs;
7a6771
   int i;
7a6771
Index: gdb-7.11.50.20160716/gdb/opencl-lang.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/opencl-lang.c	2016-07-16 14:33:42.097510471 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/opencl-lang.c	2016-07-16 14:33:44.541530140 +0200
7a6771
@@ -78,11 +78,11 @@
7a6771
 
7a6771
 static struct type *
7a6771
 lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code,
7a6771
-			   unsigned int el_length, unsigned int flag_unsigned,
7a6771
+			   ULONGEST el_length, unsigned int flag_unsigned,
7a6771
 			   int n)
7a6771
 {
7a6771
   int i;
7a6771
-  unsigned int length;
7a6771
+  ULONGEST length;
7a6771
   struct type *type = NULL;
7a6771
   struct type **types = builtin_opencl_type (gdbarch);
7a6771
 
7a6771
@@ -174,7 +174,7 @@
7a6771
   struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
7a6771
   LONGEST offset = value_offset (v);
7a6771
   LONGEST elsize = TYPE_LENGTH (eltype);
7a6771
-  int n, i, j = 0;
7a6771
+  LONGEST n, i, j = 0;
7a6771
   LONGEST lowb = 0;
7a6771
   LONGEST highb = 0;
7a6771
 
7a6771
@@ -203,7 +203,7 @@
7a6771
   struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
7a6771
   LONGEST offset = value_offset (v);
7a6771
   LONGEST elsize = TYPE_LENGTH (eltype);
7a6771
-  int n, i, j = 0;
7a6771
+  LONGEST n, i, j = 0;
7a6771
   LONGEST lowb = 0;
7a6771
   LONGEST highb = 0;
7a6771
 
7a6771
@@ -243,17 +243,17 @@
7a6771
 
7a6771
 static int
7a6771
 lval_func_check_synthetic_pointer (const struct value *v,
7a6771
-				   LONGEST offset, int length)
7a6771
+				   LONGEST offset, LONGEST length)
7a6771
 {
7a6771
   struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
7a6771
   /* Size of the target type in bits.  */
7a6771
-  int elsize =
7a6771
+  LONGEST elsize =
7a6771
       TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
7a6771
-  int startrest = offset % elsize;
7a6771
-  int start = offset / elsize;
7a6771
-  int endrest = (offset + length) % elsize;
7a6771
-  int end = (offset + length) / elsize;
7a6771
-  int i;
7a6771
+  LONGEST startrest = offset % elsize;
7a6771
+  LONGEST start = offset / elsize;
7a6771
+  LONGEST endrest = (offset + length) % elsize;
7a6771
+  LONGEST end = (offset + length) / elsize;
7a6771
+  LONGEST i;
7a6771
 
7a6771
   if (endrest)
7a6771
     end++;
7a6771
@@ -263,8 +263,8 @@
7a6771
 
7a6771
   for (i = start; i < end; i++)
7a6771
     {
7a6771
-      int comp_offset = (i == start) ? startrest : 0;
7a6771
-      int comp_length = (i == end) ? endrest : elsize;
7a6771
+      LONGEST comp_offset = (i == start) ? startrest : 0;
7a6771
+      LONGEST comp_length = (i == end) ? endrest : elsize;
7a6771
 
7a6771
       if (!value_bits_synthetic_pointer (c->val,
7a6771
 					 c->indices[i] * elsize + comp_offset,
7a6771
Index: gdb-7.11.50.20160716/gdb/p-lang.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/p-lang.c	2016-07-16 14:33:42.098510479 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/p-lang.c	2016-07-16 14:33:44.542530148 +0200
7a6771
@@ -95,8 +95,8 @@
7a6771
    are not multiple of TARGET_CHAR_BIT then the results are wrong
7a6771
    but this does not happen for Free Pascal nor for GPC.  */
7a6771
 int
7a6771
-is_pascal_string_type (struct type *type,int *length_pos,
7a6771
-                       int *length_size, int *string_pos,
7a6771
+is_pascal_string_type (struct type *type, LONGEST *length_pos,
7a6771
+		       LONGEST *length_size, LONGEST *string_pos,
7a6771
 		       struct type **char_type,
7a6771
 		       const char **arrayname)
7a6771
 {
7a6771
@@ -216,12 +216,12 @@
7a6771
 
7a6771
 void
7a6771
 pascal_printstr (struct ui_file *stream, struct type *type,
7a6771
-		 const gdb_byte *string, unsigned int length,
7a6771
+		 const gdb_byte *string, ULONGEST length,
7a6771
 		 const char *encoding, int force_ellipses,
7a6771
 		 const struct value_print_options *options)
7a6771
 {
7a6771
   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
7a6771
-  unsigned int i;
7a6771
+  ULONGEST i;
7a6771
   unsigned int things_printed = 0;
7a6771
   int in_quotes = 0;
7a6771
   int need_comma = 0;
7a6771
@@ -249,9 +249,9 @@
7a6771
     {
7a6771
       /* Position of the character we are examining
7a6771
          to see whether it is repeated.  */
7a6771
-      unsigned int rep1;
7a6771
+      ULONGEST rep1;
7a6771
       /* Number of repetitions we have detected so far.  */
7a6771
-      unsigned int reps;
7a6771
+      ULONGEST reps;
7a6771
       unsigned long int current_char;
7a6771
 
7a6771
       QUIT;
7a6771
@@ -283,7 +283,7 @@
7a6771
 	      in_quotes = 0;
7a6771
 	    }
7a6771
 	  pascal_printchar (current_char, type, stream);
7a6771
-	  fprintf_filtered (stream, " <repeats %u times>", reps);
7a6771
+	  fprintf_filtered (stream, " <repeats %s times>", pulongest (reps));
7a6771
 	  i = rep1 - 1;
7a6771
 	  things_printed += options->repeat_count_threshold;
7a6771
 	  need_comma = 1;
7a6771
Index: gdb-7.11.50.20160716/gdb/p-lang.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/p-lang.h	2016-07-16 14:33:42.098510479 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/p-lang.h	2016-07-16 14:33:44.542530148 +0200
7a6771
@@ -36,7 +36,7 @@
7a6771
 extern void pascal_print_typedef (struct type *, struct symbol *,
7a6771
 				  struct ui_file *);
7a6771
 
7a6771
-extern void pascal_val_print (struct type *, const gdb_byte *, int,
7a6771
+extern void pascal_val_print (struct type *, const gdb_byte *, LONGEST,
7a6771
 			      CORE_ADDR, struct ui_file *, int,
7a6771
 			      const struct value *,
7a6771
 			      const struct value_print_options *);
7a6771
@@ -50,13 +50,13 @@
7a6771
 /* These are in p-lang.c: */
7a6771
 
7a6771
 extern int
7a6771
-  is_pascal_string_type (struct type *, int *, int *, int *,
7a6771
+  is_pascal_string_type (struct type *, LONGEST *, LONGEST *, LONGEST *,
7a6771
 			 struct type **, const char **);
7a6771
 
7a6771
 extern void pascal_printchar (int, struct type *, struct ui_file *);
7a6771
 
7a6771
 extern void pascal_printstr (struct ui_file *, struct type *, const gdb_byte *,
7a6771
-			     unsigned int, const char *, int,
7a6771
+			     ULONGEST, const char *, int,
7a6771
 			     const struct value_print_options *);
7a6771
 
7a6771
 extern struct type **const (pascal_builtin_types[]);
7a6771
Index: gdb-7.11.50.20160716/gdb/p-valprint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/p-valprint.c	2016-07-16 14:33:42.098510479 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/p-valprint.c	2016-07-16 14:33:44.542530148 +0200
7a6771
@@ -59,7 +59,7 @@
7a6771
 
7a6771
 void
7a6771
 pascal_val_print (struct type *type, const gdb_byte *valaddr,
7a6771
-		  int embedded_offset, CORE_ADDR address,
7a6771
+		  LONGEST embedded_offset, CORE_ADDR address,
7a6771
 		  struct ui_file *stream, int recurse,
7a6771
 		  const struct value *original_value,
7a6771
 		  const struct value_print_options *options)
7a6771
@@ -70,8 +70,8 @@
7a6771
   unsigned len;
7a6771
   LONGEST low_bound, high_bound;
7a6771
   struct type *elttype;
7a6771
-  unsigned eltlen;
7a6771
-  int length_pos, length_size, string_pos;
7a6771
+  ULONGEST eltlen;
7a6771
+  LONGEST length_pos, length_size, string_pos;
7a6771
   struct type *char_type;
7a6771
   CORE_ADDR addr;
7a6771
   int want_space = 0;
7a6771
Index: gdb-7.11.50.20160716/gdb/ppc-linux-nat.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/ppc-linux-nat.c	2016-07-16 14:33:42.099510487 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/ppc-linux-nat.c	2016-07-16 14:33:44.542530148 +0200
7a6771
@@ -1449,7 +1449,7 @@
7a6771
 
7a6771
 static int
7a6771
 ppc_linux_region_ok_for_hw_watchpoint (struct target_ops *self,
7a6771
-				       CORE_ADDR addr, int len)
7a6771
+				       CORE_ADDR addr, LONGEST len)
7a6771
 {
7a6771
   /* Handle sub-8-byte quantities.  */
7a6771
   if (len <= 0)
7a6771
Index: gdb-7.11.50.20160716/gdb/printcmd.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/printcmd.c	2016-07-16 14:33:42.099510487 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/printcmd.c	2016-07-16 14:33:44.543530156 +0200
7a6771
@@ -279,7 +279,7 @@
7a6771
 		 struct ui_file *stream)
7a6771
 {
7a6771
   struct type *type = check_typedef (value_type (val));
7a6771
-  int len = TYPE_LENGTH (type);
7a6771
+  LONGEST len = TYPE_LENGTH (type);
7a6771
 
7a6771
   if (VALUE_LVAL (val) == lval_memory)
7a6771
     next_address = value_address (val) + len;
7a6771
@@ -357,7 +357,7 @@
7a6771
 {
7a6771
   struct gdbarch *gdbarch = get_type_arch (type);
7a6771
   LONGEST val_long = 0;
7a6771
-  unsigned int len = TYPE_LENGTH (type);
7a6771
+  ULONGEST len = TYPE_LENGTH (type);
7a6771
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
7a6771
 
7a6771
   /* String printing should go through val_print_scalar_formatted.  */
7a6771
Index: gdb-7.11.50.20160716/gdb/procfs.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/procfs.c	2016-07-16 14:33:42.100510495 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/procfs.c	2016-07-16 14:33:44.543530156 +0200
7a6771
@@ -4863,7 +4863,7 @@
7a6771
 
7a6771
 static int
7a6771
 procfs_region_ok_for_hw_watchpoint (struct target_ops *self,
7a6771
-				    CORE_ADDR addr, int len)
7a6771
+				    CORE_ADDR addr, LONGEST len)
7a6771
 {
7a6771
   /* The man page for proc(4) on Solaris 2.6 and up says that the
7a6771
      system can support "thousands" of hardware watchpoints, but gives
7a6771
Index: gdb-7.11.50.20160716/gdb/regcache.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/regcache.c	2016-07-16 14:33:42.101510503 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/regcache.c	2016-07-16 14:33:44.544530165 +0200
7a6771
@@ -967,7 +967,7 @@
7a6771
 
7a6771
 static enum register_status
7a6771
 regcache_xfer_part (struct regcache *regcache, int regnum,
7a6771
-		    int offset, int len, void *in, const void *out,
7a6771
+		    LONGEST offset, LONGEST len, void *in, const void *out,
7a6771
 		    enum register_status (*read) (struct regcache *regcache,
7a6771
 						  int regnum,
7a6771
 						  gdb_byte *buf),
7a6771
@@ -1011,7 +1011,7 @@
7a6771
 
7a6771
 enum register_status
7a6771
 regcache_raw_read_part (struct regcache *regcache, int regnum,
7a6771
-			int offset, int len, gdb_byte *buf)
7a6771
+			int offset, LONGEST len, gdb_byte *buf)
7a6771
 {
7a6771
   struct regcache_descr *descr = regcache->descr;
7a6771
 
7a6771
@@ -1022,7 +1022,7 @@
7a6771
 
7a6771
 void
7a6771
 regcache_raw_write_part (struct regcache *regcache, int regnum,
7a6771
-			 int offset, int len, const gdb_byte *buf)
7a6771
+			 int offset, LONGEST len, const gdb_byte *buf)
7a6771
 {
7a6771
   struct regcache_descr *descr = regcache->descr;
7a6771
 
7a6771
@@ -1033,7 +1033,7 @@
7a6771
 
7a6771
 enum register_status
7a6771
 regcache_cooked_read_part (struct regcache *regcache, int regnum,
7a6771
-			   int offset, int len, gdb_byte *buf)
7a6771
+			   LONGEST offset, LONGEST len, gdb_byte *buf)
7a6771
 {
7a6771
   struct regcache_descr *descr = regcache->descr;
7a6771
 
7a6771
@@ -1044,7 +1044,7 @@
7a6771
 
7a6771
 void
7a6771
 regcache_cooked_write_part (struct regcache *regcache, int regnum,
7a6771
-			    int offset, int len, const gdb_byte *buf)
7a6771
+			    LONGEST offset, LONGEST len, const gdb_byte *buf)
7a6771
 {
7a6771
   struct regcache_descr *descr = regcache->descr;
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/regcache.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/regcache.h	2016-07-16 14:33:42.101510503 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/regcache.h	2016-07-16 14:33:44.544530165 +0200
7a6771
@@ -80,9 +80,9 @@
7a6771
 
7a6771
 extern enum register_status
7a6771
   regcache_raw_read_part (struct regcache *regcache, int regnum,
7a6771
-			  int offset, int len, gdb_byte *buf);
7a6771
+			  int offset, LONGEST len, gdb_byte *buf);
7a6771
 void regcache_raw_write_part (struct regcache *regcache, int regnum,
7a6771
-			      int offset, int len, const gdb_byte *buf);
7a6771
+			      int offset, LONGEST len, const gdb_byte *buf);
7a6771
 
7a6771
 void regcache_invalidate (struct regcache *regcache, int regnum);
7a6771
 
7a6771
@@ -119,10 +119,11 @@
7a6771
    write style operations.  */
7a6771
 
7a6771
 enum register_status regcache_cooked_read_part (struct regcache *regcache,
7a6771
-						int regnum, int offset,
7a6771
-						int len, gdb_byte *buf);
7a6771
+						int regnum, LONGEST offset,
7a6771
+						LONGEST len, gdb_byte *buf);
7a6771
 void regcache_cooked_write_part (struct regcache *regcache, int regnum,
7a6771
-				 int offset, int len, const gdb_byte *buf);
7a6771
+				 LONGEST offset, LONGEST len,
7a6771
+				 const gdb_byte *buf);
7a6771
 
7a6771
 /* Special routines to read/write the PC.  */
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/remote.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/remote.c	2016-07-16 14:33:42.104510527 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/remote.c	2016-07-16 14:33:44.545530172 +0200
7a6771
@@ -9473,7 +9473,7 @@
7a6771
 
7a6771
 static int
7a6771
 remote_region_ok_for_hw_watchpoint (struct target_ops *self,
7a6771
-				    CORE_ADDR addr, int len)
7a6771
+				    CORE_ADDR addr, LONGEST len)
7a6771
 {
7a6771
   if (remote_hw_watchpoint_length_limit == 0)
7a6771
     return 0;
7a6771
Index: gdb-7.11.50.20160716/gdb/spu-multiarch.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/spu-multiarch.c	2016-07-16 14:33:42.105510536 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/spu-multiarch.c	2016-07-16 14:33:44.545530172 +0200
7a6771
@@ -127,7 +127,7 @@
7a6771
 /* Override the to_region_ok_for_hw_watchpoint routine.  */
7a6771
 static int
7a6771
 spu_region_ok_for_hw_watchpoint (struct target_ops *self,
7a6771
-				 CORE_ADDR addr, int len)
7a6771
+				 CORE_ADDR addr, LONGEST len)
7a6771
 {
7a6771
   struct target_ops *ops_beneath = find_target_beneath (self);
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/stack.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/stack.c	2016-07-16 14:33:42.106510544 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/stack.c	2016-07-16 14:33:44.546530181 +0200
7a6771
@@ -176,7 +176,7 @@
7a6771
    argument (not just the first nameless argument).  */
7a6771
 
7a6771
 static void
7a6771
-print_frame_nameless_args (struct frame_info *frame, long start, int num,
7a6771
+print_frame_nameless_args (struct frame_info *frame, LONGEST start, int num,
7a6771
 			   int first, struct ui_file *stream)
7a6771
 {
7a6771
   struct gdbarch *gdbarch = get_frame_arch (frame);
7a6771
@@ -537,7 +537,7 @@
7a6771
   /* Offset of next stack argument beyond the one we have seen that is
7a6771
      at the highest offset, or -1 if we haven't come to a stack
7a6771
      argument yet.  */
7a6771
-  long highest_offset = -1;
7a6771
+  LONGEST highest_offset = -1;
7a6771
   /* Number of ints of arguments that we have printed so far.  */
7a6771
   int args_printed = 0;
7a6771
   struct cleanup *old_chain;
7a6771
@@ -571,8 +571,8 @@
7a6771
 	    case LOC_ARG:
7a6771
 	    case LOC_REF_ARG:
7a6771
 	      {
7a6771
-		long current_offset = SYMBOL_VALUE (sym);
7a6771
-		int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
7a6771
+		LONGEST current_offset = SYMBOL_VALUE (sym);
7a6771
+		LONGEST arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
7a6771
 
7a6771
 		/* Compute address of next argument by adding the size of
7a6771
 		   this argument and rounding to an int boundary.  */
7a6771
@@ -707,7 +707,7 @@
7a6771
      enough about the stack to find them.  */
7a6771
   if (num != -1)
7a6771
     {
7a6771
-      long start;
7a6771
+      LONGEST start;
7a6771
 
7a6771
       if (highest_offset == -1)
7a6771
 	start = gdbarch_frame_args_skip (get_frame_arch (frame));
7a6771
Index: gdb-7.11.50.20160716/gdb/symmisc.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/symmisc.c	2016-07-16 14:33:42.107510552 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/symmisc.c	2016-07-16 14:33:44.546530181 +0200
7a6771
@@ -538,11 +538,11 @@
7a6771
 
7a6771
 	case LOC_CONST_BYTES:
7a6771
 	  {
7a6771
-	    unsigned i;
7a6771
+	    ULONGEST i;
7a6771
 	    struct type *type = check_typedef (SYMBOL_TYPE (symbol));
7a6771
 
7a6771
-	    fprintf_filtered (outfile, "const %u hex bytes:",
7a6771
-			      TYPE_LENGTH (type));
7a6771
+	    fprintf_filtered (outfile, "const %s hex bytes:",
7a6771
+			      pulongest (TYPE_LENGTH (type)));
7a6771
 	    for (i = 0; i < TYPE_LENGTH (type); i++)
7a6771
 	      fprintf_filtered (outfile, " %02x",
7a6771
 				(unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
7a6771
Index: gdb-7.11.50.20160716/gdb/target.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/target.c	2016-07-16 14:33:42.108510560 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/target.c	2016-07-16 14:33:44.546530181 +0200
7a6771
@@ -56,7 +56,7 @@
7a6771
 						 CORE_ADDR, CORE_ADDR, int);
7a6771
 
7a6771
 static int default_region_ok_for_hw_watchpoint (struct target_ops *,
7a6771
-						CORE_ADDR, int);
7a6771
+						CORE_ADDR, LONGEST);
7a6771
 
7a6771
 static void default_rcmd (struct target_ops *, const char *, struct ui_file *);
7a6771
 
7a6771
@@ -3196,7 +3196,7 @@
7a6771
 
7a6771
 static int
7a6771
 default_region_ok_for_hw_watchpoint (struct target_ops *self,
7a6771
-				     CORE_ADDR addr, int len)
7a6771
+				     CORE_ADDR addr, LONGEST len)
7a6771
 {
7a6771
   return (len <= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT);
7a6771
 }
7a6771
Index: gdb-7.11.50.20160716/gdb/target.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/target.h	2016-07-16 14:33:42.109510568 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/target.h	2016-07-16 14:33:44.547530189 +0200
7a6771
@@ -551,7 +551,7 @@
7a6771
     /* Documentation of this routine is provided with the corresponding
7a6771
        target_* macro.  */
7a6771
     int (*to_region_ok_for_hw_watchpoint) (struct target_ops *,
7a6771
-					   CORE_ADDR, int)
7a6771
+					   CORE_ADDR, LONGEST)
7a6771
       TARGET_DEFAULT_FUNC (default_region_ok_for_hw_watchpoint);
7a6771
 
7a6771
     int (*to_can_accel_watchpoint_condition) (struct target_ops *,
7a6771
Index: gdb-7.11.50.20160716/gdb/tracepoint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/tracepoint.c	2016-07-16 14:33:42.112510592 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/tracepoint.c	2016-07-16 14:33:44.547530189 +0200
7a6771
@@ -930,13 +930,13 @@
7a6771
 static void
7a6771
 add_memrange (struct collection_list *memranges, 
7a6771
 	      int type, bfd_signed_vma base,
7a6771
-	      unsigned long len)
7a6771
+	      ULONGEST len)
7a6771
 {
7a6771
   if (info_verbose)
7a6771
     {
7a6771
       printf_filtered ("(%d,", type);
7a6771
       printf_vma (base);
7a6771
-      printf_filtered (",%ld)\n", len);
7a6771
+      printf_filtered (",%s)\n", pulongest (len));
7a6771
     }
7a6771
 
7a6771
   /* type: memrange_absolute == memory, other n == basereg */
7a6771
@@ -966,7 +966,7 @@
7a6771
 		CORE_ADDR scope,
7a6771
 		int trace_string)
7a6771
 {
7a6771
-  unsigned long len;
7a6771
+  ULONGEST len;
7a6771
   unsigned int reg;
7a6771
   bfd_signed_vma offset;
7a6771
   int treat_as_expr = 0;
7a6771
@@ -990,8 +990,8 @@
7a6771
 	  char tmp[40];
7a6771
 
7a6771
 	  sprintf_vma (tmp, offset);
7a6771
-	  printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
7a6771
-			   SYMBOL_PRINT_NAME (sym), len,
7a6771
+	  printf_filtered ("LOC_STATIC %s: collect %s bytes at %s.\n",
7a6771
+			   SYMBOL_PRINT_NAME (sym), pulongest (len),
7a6771
 			   tmp /* address */);
7a6771
 	}
7a6771
       /* A struct may be a C++ class with static fields, go to general
7a6771
@@ -1023,8 +1023,8 @@
7a6771
       offset = frame_offset + SYMBOL_VALUE (sym);
7a6771
       if (info_verbose)
7a6771
 	{
7a6771
-	  printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
7a6771
-			   SYMBOL_PRINT_NAME (sym), len);
7a6771
+	  printf_filtered ("LOC_LOCAL %s: Collect %s bytes at offset ",
7a6771
+			   SYMBOL_PRINT_NAME (sym), pulongest (len));
7a6771
 	  printf_vma (offset);
7a6771
 	  printf_filtered (" from frame ptr reg %d\n", reg);
7a6771
 	}
7a6771
@@ -1035,8 +1035,8 @@
7a6771
       offset = 0;
7a6771
       if (info_verbose)
7a6771
 	{
7a6771
-	  printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
7a6771
-			   SYMBOL_PRINT_NAME (sym), len);
7a6771
+	  printf_filtered ("LOC_REGPARM_ADDR %s: Collect %s bytes at offset ",
7a6771
+			   SYMBOL_PRINT_NAME (sym), pulongest (len));
7a6771
 	  printf_vma (offset);
7a6771
 	  printf_filtered (" from reg %d\n", reg);
7a6771
 	}
7a6771
@@ -1047,8 +1047,8 @@
7a6771
       offset = frame_offset + SYMBOL_VALUE (sym);
7a6771
       if (info_verbose)
7a6771
 	{
7a6771
-	  printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
7a6771
-			   SYMBOL_PRINT_NAME (sym), len);
7a6771
+	  printf_filtered ("LOC_LOCAL %s: Collect %s bytes at offset ",
7a6771
+			   SYMBOL_PRINT_NAME (sym), pulongest (len));
7a6771
 	  printf_vma (offset);
7a6771
 	  printf_filtered (" from frame ptr reg %d\n", reg);
7a6771
 	}
7a6771
@@ -2703,7 +2703,8 @@
7a6771
   const char *symname;
7a6771
   char *save_args = args;
7a6771
   struct block_iterator iter;
7a6771
-  int j, count = 0;
7a6771
+  int count = 0;
7a6771
+  LONGEST j;
7a6771
   struct gdbarch *gdbarch;
7a6771
   int regno;
7a6771
   struct event_location *location;
7a6771
@@ -2847,8 +2848,11 @@
7a6771
 		}
7a6771
 	    }
7a6771
 	  if (SYMBOL_TYPE (sym))
7a6771
-	    printf_filtered (", length %d.\n",
7a6771
-			     TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
7a6771
+	    {
7a6771
+	      ULONGEST len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
7a6771
+
7a6771
+	      printf_filtered (", length %s.\n", pulongest (len));
7a6771
+	    }
7a6771
 	}
7a6771
       if (BLOCK_FUNCTION (block))
7a6771
 	break;
7a6771
Index: gdb-7.11.50.20160716/gdb/valarith.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/valarith.c	2016-07-16 14:33:42.114510608 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/valarith.c	2016-07-16 14:33:44.548530197 +0200
7a6771
@@ -188,7 +188,7 @@
7a6771
    to doubles, but no longer does.  */
7a6771
 
7a6771
 struct value *
7a6771
-value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound)
7a6771
+value_subscripted_rvalue (struct value *array, LONGEST index, LONGEST lowerbound)
7a6771
 {
7a6771
   struct type *array_type = check_typedef (value_type (array));
7a6771
   struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
7a6771
@@ -674,7 +674,7 @@
7a6771
   struct value *inval1;
7a6771
   struct value *inval2;
7a6771
   struct value *outval = NULL;
7a6771
-  int inval1len, inval2len;
7a6771
+  ssize_t inval1len, inval2len;
7a6771
   int count, idx;
7a6771
   char *ptr;
7a6771
   char inchar;
7a6771
@@ -1527,7 +1527,7 @@
7a6771
 int
7a6771
 value_logical_not (struct value *arg1)
7a6771
 {
7a6771
-  int len;
7a6771
+  LONGEST len;
7a6771
   const gdb_byte *p;
7a6771
   struct type *type1;
7a6771
 
7a6771
@@ -1558,11 +1558,11 @@
7a6771
 static int
7a6771
 value_strcmp (struct value *arg1, struct value *arg2)
7a6771
 {
7a6771
-  int len1 = TYPE_LENGTH (value_type (arg1));
7a6771
-  int len2 = TYPE_LENGTH (value_type (arg2));
7a6771
+  LONGEST len1 = TYPE_LENGTH (value_type (arg1));
7a6771
+  LONGEST len2 = TYPE_LENGTH (value_type (arg2));
7a6771
   const gdb_byte *s1 = value_contents (arg1);
7a6771
   const gdb_byte *s2 = value_contents (arg2);
7a6771
-  int i, len = len1 < len2 ? len1 : len2;
7a6771
+  LONGEST i, len = len1 < len2 ? len1 : len2;
7a6771
 
7a6771
   for (i = 0; i < len; i++)
7a6771
     {
7a6771
Index: gdb-7.11.50.20160716/gdb/valops.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/valops.c	2016-07-16 14:33:42.117510632 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/valops.c	2016-07-16 14:33:44.548530197 +0200
7a6771
@@ -79,7 +79,7 @@
7a6771
 					   int, int);
7a6771
 
7a6771
 static struct value *value_struct_elt_for_reference (struct type *,
7a6771
-						     int, struct type *,
7a6771
+						     LONGEST, struct type *,
7a6771
 						     const char *,
7a6771
 						     struct type *,
7a6771
 						     int, enum noside);
7a6771
@@ -183,7 +183,7 @@
7a6771
    space.  */
7a6771
 
7a6771
 struct value *
7a6771
-value_allocate_space_in_inferior (int len)
7a6771
+value_allocate_space_in_inferior (LONGEST len)
7a6771
 {
7a6771
   struct objfile *objf;
7a6771
   struct value *val = find_function_in_inferior ("malloc", &objf);
7a6771
@@ -397,12 +397,12 @@
7a6771
   if (code1 == TYPE_CODE_ARRAY)
7a6771
     {
7a6771
       struct type *element_type = TYPE_TARGET_TYPE (type);
7a6771
-      unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
7a6771
+      ULONGEST element_length = TYPE_LENGTH (check_typedef (element_type));
7a6771
 
7a6771
       if (element_length > 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
7a6771
 	{
7a6771
 	  struct type *range_type = TYPE_INDEX_TYPE (type);
7a6771
-	  int val_length = TYPE_LENGTH (type2);
7a6771
+	  LONGEST val_length = TYPE_LENGTH (type2);
7a6771
 	  LONGEST low_bound, high_bound, new_length;
7a6771
 
7a6771
 	  if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
7a6771
@@ -1063,7 +1063,7 @@
7a6771
       {
7a6771
 	const gdb_byte *dest_buffer;
7a6771
 	CORE_ADDR changed_addr;
7a6771
-	int changed_len;
7a6771
+	LONGEST changed_len;
7a6771
         gdb_byte buffer[sizeof (LONGEST)];
7a6771
 
7a6771
 	if (value_bitsize (toval))
7a6771
@@ -3328,7 +3328,7 @@
7a6771
    the form "DOMAIN::NAME".  */
7a6771
 
7a6771
 static struct value *
7a6771
-value_struct_elt_for_reference (struct type *domain, int offset,
7a6771
+value_struct_elt_for_reference (struct type *domain, LONGEST offset,
7a6771
 				struct type *curtype, const char *name,
7a6771
 				struct type *intype, 
7a6771
 				int want_address,
7a6771
@@ -3362,7 +3362,7 @@
7a6771
 	  if (want_address)
7a6771
 	    return value_from_longest
7a6771
 	      (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
7a6771
-	       offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
7a6771
+	       offset + (TYPE_FIELD_BITPOS (t, i) >> 3));
7a6771
 	  else if (noside != EVAL_NORMAL)
7a6771
 	    return allocate_value (TYPE_FIELD_TYPE (t, i));
7a6771
 	  else
7a6771
@@ -3530,7 +3530,7 @@
7a6771
   for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
7a6771
     {
7a6771
       struct value *v;
7a6771
-      int base_offset;
7a6771
+      LONGEST base_offset;
7a6771
 
7a6771
       if (BASETYPE_VIA_VIRTUAL (t, i))
7a6771
 	base_offset = 0;
7a6771
@@ -3679,7 +3679,7 @@
7a6771
 struct value *
7a6771
 value_full_object (struct value *argp, 
7a6771
 		   struct type *rtype, 
7a6771
-		   int xfull, int xtop,
7a6771
+		   int xfull, LONGEST xtop,
7a6771
 		   int xusing_enc)
7a6771
 {
7a6771
   struct type *real_type;
7a6771
Index: gdb-7.11.50.20160716/gdb/valprint.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/valprint.c	2016-07-16 14:33:42.118510640 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/valprint.c	2016-07-16 14:33:44.549530205 +0200
7a6771
@@ -907,7 +907,7 @@
7a6771
 
7a6771
 void
7a6771
 generic_val_print (struct type *type, const gdb_byte *valaddr,
7a6771
-		   int embedded_offset, CORE_ADDR address,
7a6771
+		   LONGEST embedded_offset, CORE_ADDR address,
7a6771
 		   struct ui_file *stream, int recurse,
7a6771
 		   const struct value *original_value,
7a6771
 		   const struct value_print_options *options,
7a6771
@@ -1842,7 +1842,7 @@
7a6771
 
7a6771
 void
7a6771
 print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
7a6771
-		 unsigned len, enum bfd_endian byte_order)
7a6771
+		 ULONGEST len, enum bfd_endian byte_order)
7a6771
 {
7a6771
   const gdb_byte *p;
7a6771
 
7a6771
@@ -1964,17 +1964,17 @@
7a6771
 			  int recurse,
7a6771
 			  const struct value *val,
7a6771
 			  const struct value_print_options *options,
7a6771
-			  unsigned int i)
7a6771
+			  ULONGEST i)
7a6771
 {
7a6771
   unsigned int things_printed = 0;
7a6771
-  unsigned len;
7a6771
+  ULONGEST len;
7a6771
   struct type *elttype, *index_type, *base_index_type;
7a6771
-  unsigned eltlen;
7a6771
+  ULONGEST eltlen;
7a6771
   /* Position of the array element we are examining to see
7a6771
      whether it is repeated.  */
7a6771
-  unsigned int rep1;
7a6771
+  ULONGEST rep1;
7a6771
   /* Number of repetitions we have detected so far.  */
7a6771
-  unsigned int reps;
7a6771
+  ULONGEST reps;
7a6771
   LONGEST low_bound, high_bound;
7a6771
   LONGEST low_pos, high_pos;
7a6771
 
7a6771
@@ -2064,7 +2064,7 @@
7a6771
 		     address, stream, recurse + 1, val, options,
7a6771
 		     current_language);
7a6771
 	  annotate_elt_rep (reps);
7a6771
-	  fprintf_filtered (stream, " <repeats %u times>", reps);
7a6771
+	  fprintf_filtered (stream, " <repeats %s times>", pulongest (reps));
7a6771
 	  annotate_elt_rep_end ();
7a6771
 
7a6771
 	  i = rep1 - 1;
7a6771
@@ -2720,7 +2720,7 @@
7a6771
 
7a6771
 void
7a6771
 generic_printstr (struct ui_file *stream, struct type *type, 
7a6771
-		  const gdb_byte *string, unsigned int length, 
7a6771
+		  const gdb_byte *string, ULONGEST length,
7a6771
 		  const char *encoding, int force_ellipses,
7a6771
 		  int quote_char, int c_style_terminator,
7a6771
 		  const struct value_print_options *options)
7a6771
Index: gdb-7.11.50.20160716/gdb/valprint.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/valprint.h	2016-07-16 14:33:42.118510640 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/valprint.h	2016-07-16 14:33:44.549530205 +0200
7a6771
@@ -119,7 +119,7 @@
7a6771
 				      CORE_ADDR, struct ui_file *, int,
7a6771
 				      const struct value *,
7a6771
 				      const struct value_print_options *,
7a6771
-				      unsigned int);
7a6771
+				      ULONGEST);
7a6771
 
7a6771
 extern void val_print_type_code_int (struct type *, const gdb_byte *,
7a6771
 				     struct ui_file *);
7a6771
@@ -141,7 +141,7 @@
7a6771
 				 unsigned int, enum bfd_endian);
7a6771
 
7a6771
 extern void print_hex_chars (struct ui_file *, const gdb_byte *,
7a6771
-			     unsigned int, enum bfd_endian);
7a6771
+			     ULONGEST, enum bfd_endian);
7a6771
 
7a6771
 extern void print_char_chars (struct ui_file *, struct type *,
7a6771
 			      const gdb_byte *, unsigned int, enum bfd_endian);
7a6771
@@ -194,7 +194,7 @@
7a6771
 
7a6771
 
7a6771
 extern void generic_val_print (struct type *type, const gdb_byte *valaddr,
7a6771
-			       int embedded_offset, CORE_ADDR address,
7a6771
+			       LONGEST embedded_offset, CORE_ADDR address,
7a6771
 			       struct ui_file *stream, int recurse,
7a6771
 			       const struct value *original_value,
7a6771
 			       const struct value_print_options *options,
7a6771
@@ -204,7 +204,7 @@
7a6771
 			       int quoter, const char *encoding);
7a6771
 
7a6771
 extern void generic_printstr (struct ui_file *stream, struct type *type, 
7a6771
-			      const gdb_byte *string, unsigned int length, 
7a6771
+			      const gdb_byte *string, ULONGEST length,
7a6771
 			      const char *encoding, int force_ellipses,
7a6771
 			      int quote_char, int c_style_terminator,
7a6771
 			      const struct value_print_options *options);
7a6771
Index: gdb-7.11.50.20160716/gdb/value.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/value.c	2016-07-16 14:33:42.119510648 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/value.c	2016-07-16 14:33:44.549530205 +0200
7a6771
@@ -366,7 +366,8 @@
7a6771
 }
7a6771
 
7a6771
 int
7a6771
-value_bits_any_optimized_out (const struct value *value, int bit_offset, int bit_length)
7a6771
+value_bits_any_optimized_out (const struct value *value, LONGEST bit_offset,
7a6771
+			      LONGEST bit_length)
7a6771
 {
7a6771
   gdb_assert (!value->lazy);
7a6771
 
7a6771
@@ -812,9 +813,9 @@
7a6771
    Return true if the available bits match.  */
7a6771
 
7a6771
 static int
7a6771
-value_contents_bits_eq (const struct value *val1, int offset1,
7a6771
-			const struct value *val2, int offset2,
7a6771
-			int length)
7a6771
+value_contents_bits_eq (const struct value *val1, LONGEST offset1,
7a6771
+			const struct value *val2, LONGEST offset2,
7a6771
+			LONGEST length)
7a6771
 {
7a6771
   /* Each array element corresponds to a ranges source (unavailable,
7a6771
      optimized out).  '1' is for VAL1, '2' for VAL2.  */
7a6771
@@ -1456,7 +1457,8 @@
7a6771
    the following LENGTH bytes.  */
7a6771
 
7a6771
 void
7a6771
-mark_value_bytes_optimized_out (struct value *value, int offset, int length)
7a6771
+mark_value_bytes_optimized_out (struct value *value, LONGEST offset,
7a6771
+				LONGEST length)
7a6771
 {
7a6771
   mark_value_bits_optimized_out (value,
7a6771
 				 offset * TARGET_CHAR_BIT,
7a6771
Index: gdb-7.11.50.20160716/gdb/value.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/value.h	2016-07-16 14:33:42.120510656 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/value.h	2016-07-16 14:33:44.550530213 +0200
7a6771
@@ -246,7 +246,7 @@
7a6771
   /* If non-NULL, this is used to determine whether the indicated bits
7a6771
      of VALUE are a synthetic pointer.  */
7a6771
   int (*check_synthetic_pointer) (const struct value *value,
7a6771
-				  LONGEST offset, int length);
7a6771
+				  LONGEST offset, LONGEST length);
7a6771
 
7a6771
   /* Return a duplicate of VALUE's closure, for use in a new value.
7a6771
      This may simply return the same closure, if VALUE's is
7a6771
@@ -377,7 +377,8 @@
7a6771
    otherwise.  */
7a6771
 
7a6771
 extern int value_bits_any_optimized_out (const struct value *value,
7a6771
-					 int bit_offset, int bit_length);
7a6771
+					 LONGEST bit_offset,
7a6771
+					 LONGEST bit_length);
7a6771
 
7a6771
 /* Like value_optimized_out, but return true iff the whole value is
7a6771
    optimized out.  */
7a6771
@@ -387,7 +388,7 @@
7a6771
    LENGTH bytes as optimized out.  */
7a6771
 
7a6771
 extern void mark_value_bytes_optimized_out (struct value *value,
7a6771
-					    int offset, int length);
7a6771
+					    LONGEST offset, LONGEST length);
7a6771
 
7a6771
 /* Mark VALUE's content bits starting at OFFSET and extending for
7a6771
    LENGTH bits as optimized out.  */
7a6771
@@ -771,12 +772,11 @@
7a6771
 					    int fieldno,
7a6771
 					    struct type *arg_type);
7a6771
 
7a6771
-
7a6771
 extern struct type *value_rtti_indirect_type (struct value *, int *, LONGEST *,
7a6771
 					      int *);
7a6771
 
7a6771
 extern struct value *value_full_object (struct value *, struct type *, int,
7a6771
-					int, int);
7a6771
+					LONGEST, int);
7a6771
 
7a6771
 extern struct value *value_cast_pointers (struct type *, struct value *, int);
7a6771
 
7a6771
@@ -1065,10 +1065,11 @@
7a6771
 extern struct value *find_function_in_inferior (const char *,
7a6771
 						struct objfile **);
7a6771
 
7a6771
-extern struct value *value_allocate_space_in_inferior (int);
7a6771
+extern struct value *value_allocate_space_in_inferior (LONGEST);
7a6771
 
7a6771
 extern struct value *value_subscripted_rvalue (struct value *array,
7a6771
-					       LONGEST index, int lowerbound);
7a6771
+					       LONGEST index,
7a6771
+					       LONGEST lowerbound);
7a6771
 
7a6771
 /* User function handler.  */
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/s390-linux-nat.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/s390-linux-nat.c	2016-07-16 14:33:42.120510656 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/s390-linux-nat.c	2016-07-16 14:33:44.550530213 +0200
7a6771
@@ -612,7 +612,7 @@
7a6771
 
7a6771
 static int
7a6771
 s390_region_ok_for_hw_watchpoint (struct target_ops *self,
7a6771
-				  CORE_ADDR addr, int cnt)
7a6771
+				  CORE_ADDR addr, LONGEST cnt)
7a6771
 {
7a6771
   return 1;
7a6771
 }
7a6771
Index: gdb-7.11.50.20160716/gdb/target-delegates.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/target-delegates.c	2016-07-16 14:33:42.121510664 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/target-delegates.c	2016-07-16 14:33:44.550530213 +0200
7a6771
@@ -736,14 +736,14 @@
7a6771
 }
7a6771
 
7a6771
 static int
7a6771
-delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
7a6771
+delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, LONGEST arg2)
7a6771
 {
7a6771
   self = self->beneath;
7a6771
   return self->to_region_ok_for_hw_watchpoint (self, arg1, arg2);
7a6771
 }
7a6771
 
7a6771
 static int
7a6771
-debug_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
7a6771
+debug_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, LONGEST arg2)
7a6771
 {
7a6771
   int result;
7a6771
   fprintf_unfiltered (gdb_stdlog, "-> %s->to_region_ok_for_hw_watchpoint (...)\n", debug_target.to_shortname);
7a6771
@@ -753,7 +753,7 @@
7a6771
   fputs_unfiltered (", ", gdb_stdlog);
7a6771
   target_debug_print_CORE_ADDR (arg1);
7a6771
   fputs_unfiltered (", ", gdb_stdlog);
7a6771
-  target_debug_print_int (arg2);
7a6771
+  target_debug_print_LONGEST (arg2);
7a6771
   fputs_unfiltered (") = ", gdb_stdlog);
7a6771
   target_debug_print_int (result);
7a6771
   fputs_unfiltered ("\n", gdb_stdlog);
7a6771
Index: gdb-7.11.50.20160716/gdb/aarch64-linux-nat.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/aarch64-linux-nat.c	2016-07-16 14:33:42.122510672 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/aarch64-linux-nat.c	2016-07-16 14:33:44.551530221 +0200
7a6771
@@ -736,7 +736,7 @@
7a6771
 
7a6771
 static int
7a6771
 aarch64_linux_region_ok_for_hw_watchpoint (struct target_ops *self,
7a6771
-					   CORE_ADDR addr, int len)
7a6771
+					   CORE_ADDR addr, LONGEST len)
7a6771
 {
7a6771
   return aarch64_linux_region_ok_for_watchpoint (addr, len);
7a6771
 }
7a6771
Index: gdb-7.11.50.20160716/gdb/nat/x86-dregs.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/nat/x86-dregs.c	2016-07-16 14:33:42.122510672 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/nat/x86-dregs.c	2016-07-16 14:33:44.551530221 +0200
7a6771
@@ -384,7 +384,7 @@
7a6771
 
7a6771
 static int
7a6771
 x86_handle_nonaligned_watchpoint (struct x86_debug_reg_state *state,
7a6771
-				  x86_wp_op_t what, CORE_ADDR addr, int len,
7a6771
+				  x86_wp_op_t what, CORE_ADDR addr, LONGEST len,
7a6771
 				  enum target_hw_bp_type type)
7a6771
 {
7a6771
   int retval = 0;
7a6771
@@ -552,7 +552,7 @@
7a6771
 
7a6771
 int
7a6771
 x86_dr_region_ok_for_watchpoint (struct x86_debug_reg_state *state,
7a6771
-				 CORE_ADDR addr, int len)
7a6771
+				 CORE_ADDR addr, LONGEST len)
7a6771
 {
7a6771
   int nregs;
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/compile/compile-c-support.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/compile/compile-c-support.c	2016-07-16 14:33:42.122510672 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/compile/compile-c-support.c	2016-07-16 14:33:44.551530221 +0200
7a6771
@@ -299,11 +299,11 @@
7a6771
 
7a6771
 	      default:
7a6771
 		fprintf_unfiltered (stream,
7a6771
-				    "  unsigned char %s[%d]"
7a6771
+				    "  unsigned char %s[%s]"
7a6771
 				    " __attribute__((__aligned__("
7a6771
 				    "__BIGGEST_ALIGNMENT__)))",
7a6771
 				    regname,
7a6771
-				    TYPE_LENGTH (regtype));
7a6771
+				    pulongest (TYPE_LENGTH (regtype)));
7a6771
 	      }
7a6771
 	    fputs_unfiltered (";\n", stream);
7a6771
 
7a6771
Index: gdb-7.11.50.20160716/gdb/nat/x86-dregs.h
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/nat/x86-dregs.h	2016-07-16 14:33:42.122510672 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/nat/x86-dregs.h	2016-07-16 14:33:44.551530221 +0200
7a6771
@@ -116,7 +116,7 @@
7a6771
 /* Return non-zero if we can watch a memory region that starts at
7a6771
    address ADDR and whose length is LEN bytes.  */
7a6771
 extern int x86_dr_region_ok_for_watchpoint (struct x86_debug_reg_state *state,
7a6771
-					    CORE_ADDR addr, int len);
7a6771
+					    CORE_ADDR addr, LONGEST len);
7a6771
 
7a6771
 /* If the inferior has some break/watchpoint that triggered, set the
7a6771
    address associated with that break/watchpoint and return true.
7a6771
Index: gdb-7.11.50.20160716/gdb/x86-nat.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/x86-nat.c	2016-07-16 14:33:42.123510680 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/x86-nat.c	2016-07-16 14:33:44.551530221 +0200
7a6771
@@ -174,7 +174,7 @@
7a6771
 
7a6771
 static int
7a6771
 x86_region_ok_for_watchpoint (struct target_ops *self,
7a6771
-			      CORE_ADDR addr, int len)
7a6771
+			      CORE_ADDR addr, LONGEST len)
7a6771
 {
7a6771
   struct x86_debug_reg_state *state
7a6771
     = x86_debug_reg_state (ptid_get_pid (inferior_ptid));
7a6771
Index: gdb-7.11.50.20160716/gdb/rust-lang.c
7a6771
===================================================================
7a6771
--- gdb-7.11.50.20160716.orig/gdb/rust-lang.c	2016-07-16 14:33:42.123510680 +0200
7a6771
+++ gdb-7.11.50.20160716/gdb/rust-lang.c	2016-07-16 14:33:44.551530221 +0200
7a6771
@@ -410,7 +410,7 @@
7a6771
 
7a6771
 static void
7a6771
 rust_printstr (struct ui_file *stream, struct type *type,
7a6771
-	       const gdb_byte *string, unsigned int length,
7a6771
+	       const gdb_byte *string, ULONGEST length,
7a6771
 	       const char *user_encoding, int force_ellipses,
7a6771
 	       const struct value_print_options *options)
7a6771
 {
7a6771
@@ -456,7 +456,7 @@
7a6771
 /* la_val_print implementation for Rust.  */
7a6771
 
7a6771
 static void
7a6771
-rust_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
7a6771
+rust_val_print (struct type *type, const gdb_byte *valaddr, LONGEST embedded_offset,
7a6771
 		CORE_ADDR address, struct ui_file *stream, int recurse,
7a6771
 		const struct value *val,
7a6771
 		const struct value_print_options *options)