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

Siddhesh Poyarekar
2012-05-04T13:10:21Z

[-- Attachment #1: Type: text/plain, Size: 28551 bytes --]

Hi,

I have finally finished this off with a combined patch to expand bitpos
to LONGEST and type.length to ULONGEST. A quick recap of the problem
I'm trying to solve:

Currently gdb stores type sizes and struct offsets in 32-bit unsigned
and int respectively, which overflows for larger values. This patch
extends these values and all its usages throughout the code to the
longest possible values so that gdb can read larger structs, arrays and
ofsets within those structs and arrays.

An initial patch had gone in to avoid overloading the meaning of
structure offset with enum values, primarily to allow bitpos to be
defined as ULONGEST:

http://sourceware.org/ml/gdb-patches/2012-04/msg00538.html

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

I have attached the test case patch as a separate file. Below is the
changelog.

Regards,
Siddhesh

gdb/ChangeLog

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

* ada-lang.c (fat_pntr_bounds_bitpos): Return LONGEST.
(fat_pntr_data_bitpos): Likewise.
(desc_bound_bitpos): Likewise.
(constrained_packed_array_type): Expand elt_bits parameter to
LONGEST.
(move_bits): Expand parameters src_offset and n to ULONGEST.
(ada_index_struct_field): Expand parameters index and offset to
LONGEST.
(cond_offset_host): Expand parameter offset to LONGEST.
(cond_offset_target): Likewise.
(ada_type_of_array): Expand array_bitsize to LONGEST.
(decode_constrained_packed_array_type): Expand bits to ULONGEST.
(decode_constrained_packed_array): Expand bit_pos to LONGEST.
(ada_value_primitive_packed_val): Expand parameter offset to
LONGEST. Expand targ to LONGEST and ntarg to ULONGEST.
(ada_value_assign): Expand from_size to ULONGEST.
(value_assign_to_component): Expand bits to ULONGEST.
(ensure_lval): Expand len to ULONGEST.
(value_pointer): Likewise.
(value_tag_from_contents_and_address): Expand tag_byte_offset to
LONGEST.
(ada_value_primitive_field): Expand parameter offset to LONGEST.
Expand bit_pos to LONGEST.
(find_struct_field): Expand parameters offset and byte_offset_p
to LONGEST. Expand bit_pos and fld_offset to LONGEST.
(ada_search_struct_field): Expand parameter offset to LONGEST.
Expand var_offset to LONGEST.
(ada_index_struct_field): Expand parameters index and offset to
LONGEST.
(ada_index_struct_field_1): Expand parameters index_p and offset
to LONGEST.
(ada_value_struct_elt): Expand byte_offset to LONGEST.
(align_value): Return ULONGEST. Expand parameter off to LONGEST
and alignment to ULONGEST.
(ada_template_to_fixed_record_type_1): Expand off, bit_len and
fld_bit_len to ULONGEST. Expand field_offset to LONGEST. Use
pulongest function to print TYPE_LENGTH.
(to_fixed_array_type): Expand len to ULONGEST.
* ada-lang.h (ada_val_print): Expand parameter embedded_offset
to LONGEST.
(ada_printstr): Expand parameter length to ULONGEST.
(ada_value_primitive_packed_val): Expand parameter offset to
LONGEST.
* ada-typeprint.c (ada_print_type): Use pulongest to print
TYPE_LENGTH.
* ada-valprint.c (val_print_packed_array_elements): Expand
eltlen to ULONGEST.
(char_at): Expand parameter i to ULONGEST.
(printstr): Expand parameter length to ULONGEST.
(ada_printstr): Likewise.
(ada_val_print): Expand embedded_offset to LONGEST.
(ada_val_print_array): Expand eltlen, len and temp_len to
ULONGEST.
(ada_val_print_1): Expand parameter offset to ULONGEST. Expand
len to ULONGEST.
(print_variant_part): Expand parameters offset and outer_offset
to LONGEST.
(print_field_values): Likewise. Expand bit_pos to LONGEST.
* alpha-tdep.c (struct alpha_arg): Expand member len to
ULONGEST.
(alpha_push_dummy_call): Expand len to ULONGEST.
(alpha_extract_return_value): Expand length to ULONGEST.
(alpha_store_return_value): Likewise.
* amd64-tdep.c (amd64_classify_aggregate): Expand len,
bitsize, endpos to ULONGEST and pos to LONGEST.
(amd64_classify): Expand len to ULONGEST.
(amd64_return_value): Expand len to LONGEST.
(amd64_push_arguments): Expand num_elements, element to ULONGEST
and len to LONGEST.
(amd64_get_longjmp_target): Expand len to ULONGEST.
* amd64-windows-tdep.c (amd64_windows_return_value): Expand
len to LONGEST.
* arm-tdep.c (arm_push_dummy_call): Expand len to LONGEST.
(arm_extract_return_value): Expand len to ULONGEST.
(arm_store_return_value): Likewise.
* avr-tdep.c (avr_return_value): Expand i to ULONGEST.
(push_stack_item): Expand parameter len to ULONGEST.
(avr_push_dummy_call): Expand last_regnum, len to ULONGEST.
* ax-gdb.c (gen_trace_static_fields): Expand length to
ULONGEST.
(gen_traced_pop): Likewise.
(gen_left_shift): Expand parameter distance to LONGEST.
(gen_offset): Expand parameter offset to LONGEST.
(gen_bitfield_ref): Expand parameters start, end to LONGEST.
Expand bound_start, bound_endi, offset to LONGEST.
(gen_primitive_field): Expand parameter offset to LONGEST.
(gen_struct_ref_recursive): Likewise.
* bfin-tdep.c (bfin_push_dummy_call): Expand total_len, len,
container_len to ULONGEST.
(bfin_extract_return_value): Expand len to LONGEST.
(bfin_store_return_value): Likewise.
* breakpoint.c (update_watchpoint): Expand len to ULONGEST.
(can_use_hardware_watchpoint): Likewise.
(invalidate_bp_value_on_memory_change): Expand parameter len to
LONGEST.
* breakpoint.h (struct bp_location): Expand member length to
ULONGEST.
* c-lang.c (c_printstr): Expand parameter length to ULONGEST.
Remove unused variable width.
(evaluate_subexp_c): Expand element_size, i to ULONGEST.
* c-lang.h (c_val_print): Expand parameter embedded_offset to
LONGEST.
(c_printstr): Expand parameter length to ULONGEST.
(cp_print_value_fields): Expand parameter offset to LONGEST.
(cp_print_value_fields_rtti): Likewise.
* c-typeprint.c (c_type_print_varspec_suffix): Remove cast
down to int and use pulongest to print ULONGEST.
* c-valprint.c (c_val_print): Expand parameter embedded_offset
to LONGEST. Expand offset to LONGEST, eltlen to ULONGEST.
(c_value_print): Expand top to LONGEST.
* corefile.c (read_memory): Expand len to ULONGEST.
(read_stack): Likewise.
(write_memory): Likewise.
* cp-abi.c (baseclass_offset): Return LONGEST. Expand
parameter embedded_offset to LONGEST. Expand res to LONGEST.
(value_virtual_fn_field): Expand parameter offset to LONGEST.
(value_rtti_type): Expand parameter top to LONGEST *.
* cp-abi.h (value_virtual_fn_field): Expand offset to LONGEST.
(value_rtti_type): Expand top to LONGEST *.
(baseclass_offset): Return LONGEST. Expand parameter
embedded_offset to LONGEST.
(struct cp_abi_ops): Expand parameter offset for
virtual_fn_field to LONGEST. Expand parameter top to LONGEST
* in value_rtti_type. Return LONGEST from baseclass_offset
and expand parameter for embedded_offset to LONGEST.
* cp-valprint.c (cp_print_value_fields): Expand parameter
offset to LONGEST.
(cp_print_value_fields_rtti): Likewise. Expand top to LONGEST.
(cp_print_value): Expand parameter offset to LONGEST. Expand
thisoffset, boffset to LONGEST.
(cp_find_class_member): Expand bitsize to ULONGEST.
* cris-tdep.c (push_stack_item): Expand parameter len to
ULONGEST.
(cris_push_dummy_call): Expand len, reg_demand, i to ULONGEST.
(cris_store_return_value): Expand len to ULONGEST.
(cris_extract_return_value): Likewise.
* d-lang.h (d_val_print): Expand parameter embedded_offset to
LONGEST.
* d-valprint.c (dynamic_array_type): Likewise.
(d_val_print): Likewise.
* doc/observer.texi (memory_changed): Expand parameter len to
LONGEST.
* doublest.c (floatformat_from_length): Likewise. Use
pulongest to format string for ULONGEST.
* dwarf2loc.c (copy_bitwise): Expand parameters
dest_offset_bits, bit_count to ULONGEST. Rename parameter
source_offset_bits to source_offset and expand to ULONGEST. New
variable source_offset_bits.
(read_pieced_value): Expand offset, dest_offset_bits,
source_offset_bits, source_offset to LONGEST. Expand type_len,
this_size, this_size_bits to ULONGEST.
(write_pieced_value): Expand type_len, this_size, this_size_bits
to ULONGEST. Expand dest_offset_bits, source_offset_bits,
dest_offset, source_offset to LONGEST.
(check_pieced_value_bits): Expand parameter bit_length to
ULONGEST.
(check_pieced_value_validity): Likewise.
(check_pieced_synthetic_pointer): Likewise.
(indirect_pieced_value): Expand bit_length to ULONGEST. Expand
bit_offset to LONGEST.
(dwarf2_evaluate_loc_desc_full): Expand n to ULONGEST.
* dwarf2read.c (struct dwarf_block): ULONGEST size.
(dwarf2_const_value_length_mismatch_complaint): Expand
parameters arg2 and arg3 to ULONGEST. Use pulongest to print
arg2 and arg3. (dwarf2_add_field): Expand anonymous size to
ULONGEST. (dump_die_shallow): Use pulongest to print
dwarf_block.size.
* eval.c (evaluate_struct_tuple): Expand bitpos to LONGEST.
(init_array_element): Expand element_size to ULONGEST.
(binop_promote): Expand promoted_len1, promoted_len2, result_len
to ULONGEST.
(evaluate_subexp_standard): Expand mem_offset, top to LONGEST.
Expand element_size to ULONGEST.
* f-lang.c (f_printstr): Expand parameter length to ULONGEST.
* f-lang.h (f_val_print): Expand parameter embedded_offset to
LONGEST.
* f-valprint.c (f77_array_offset_tbl): Make LONGEST.
(f77_create_arrayprint_offset_tbl): Expand eltlen to ULONGEST.
(f77_print_array_1): Expand parameter embedded_offset to
LONGEST. (f77_print_array): Likewise.
(f_val_print): Likewise. Expand offset to LONGEST.
* findcmd.c (parse_find_args): Expand val_bytes to ULONGEST.
* findvar.c (extract_unsigned_integer): Remove unnecessary
cast.
(default_read_var_value): Expand len to ULONGEST.
(default_value_from_register): Likewise.
(read_frame_register_value): Expand offset, reg_offset to
LONGEST. Expand len, reg_len to ULONGEST.
* frv-tdep.c (frv_extract_return_value): Expand len to
ULONGEST. Use pulongest to format print len.
(frv_push_dummy_call): Expand len to ULONGEST.
(frv_store_return_value): Likewise. Use pulongest to format
print len.
* gdbcore.h (read_memory): Expand parameter len to ULONGEST.
(read_stack): Likewise.
(write_memory): Likewise.
* gdbtypes.c (init_type): Expand parameter length to ULONGEST.
(is_unique_ancestor_worker): Expand parameters offset,
embedded_offset to LONGEST. Expand this_offset to LONGEST.
(recursive_dump_type): Use pulongest to format print
TYPE_LENGTH. Use plongest to format print TYPE_FIELD_BITPOS.
(arch_type): Expand parameter length to ULONGEST.
* gdbtypes.h (type.main_type.fld_bnds.fields): Expand bitpos
to LONGEST.
(type): Expand length to ULONGEST.
(init_type): Expand parameter length to ULONGEST.
(arch_type): Likewise.
* gnu-v2-abi.c (gnuv2_virtual_fn_field): Expand parameter
offset to LONGEST.
(gnuv2_value_rtti_type): Expand parameter top to LONGEST *.
(gnuv2_baseclass_offset): Return LONGEST. Expand parameter
embedded_offset to LONGEST. Expand field_offset, boffset to
LONGEST, field_length to ULONGEST.
* gnu-v3-abi.c (build_gdb_vtable_type): Expand offset to
LONGEST.
(vtable_address_point_offset): Return LONGEST.
(gnuv3_rtti_type): Expand parameter top_p to LONGEST *.
(gnuv3_virtual_fn_field): Expand parameter offset to LONGEST.
(gnuv3_baseclass_offset): Return LONGEST. Expand parameter
embedded_ofset to LONGEST. Expand cur_base_offset, base_offset
to LONGEST.
(gnuv3_find_method_in): Expand pos to LONGEST.
* go-lang.h (go_val_print): Expand parameter embedded_offset
to LONGEST.
* go-valprint.c (go_val_print): Likewise.
* h8300-tdep.c (h8300_push_dummy_call): Expand stack_alloc,
stack_offset, len, padded_len, offset to LONGEST.
* hppa-tdep.c (hppa64_push_dummy_call): Expand len to
ULONGEST.
(hppa64_return_value): Likewise.
* i386-darwin-tdep.c (i386_darwin_arg_type_alignment): Return
ULONGEST. Expand res to ULONGEST.
(i386_darwin_push_dummy_call): Expand arg_spaces, len, align to
ULONGEST.
* i386-nat.c (i386_handle_nonaligned_watchpoint): Expand
parameter len to ULONGEST.
(i386_region_ok_for_watchpoint): Expand parameter len to
LONGEST.
* i386-tdep.c (i386_push_dummy_call): Expand arg_space,
arg_space_used, len to ULONGEST.
(i386_extract_return_value): Expand len to ULONGEST. Use
pulongest to format print len.
(i386_store_return_value): Likewise.
* ia64-tdep.c (ia64_extract_return_value): Expand n to
ULONGEST.
(ia64_store_return_value): Likewise.
(ia64_push_dummy_call): Expand argoffset, len, nslots, memslots
to ULONGEST.
* infcall.c (call_function_by_hand): Expand len to ULONGEST.
* infrun.c (save_infcall_suspend_state): Expand len to
ULONGEST.
(restore_infcall_suspend_state): Eliminate single-use variable
len.
* iq2000-tdep.c (iq2000_store_return_value): Expand len to
ULONGEST.
(iq2000_extract_return_value): Likewise. Use len instead of
TYPE_LENGTH.
(iq2000_push_dummy_call): Expand typelen, stackspace to
ULONGEST.
* jv-lang.c (java_link_class_type): Expand boffset to LONGEST.
(java_printstr): Expand parameter length to ULONGEST.
* jv-lang.h (java_val_print): Expand parameter embedded_offset
to LONGEST.
* jv-valprint.c (java_print_value_fields): Expand parameter
offset to LONGEST.
(java_val_print): Expand parameter embedded_offset to LONGEST.
* language.c (unk_lang_printstr): Expand parameter length to
ULONGEST.
(unk_lang_val_print): Expand parameter embedded_offset to
LONGEST.
* language.h (language_defn): Expand parameter length of
la_printstr to ULONGEST. Expand parameter embedded_offset of
la_val_print to LONGEST.
* lm32-tdep.c (lm32_push_dummy_call): Expand len to ULONGEST.
(lm32_store_return_value): Likewise.
* m2-lang.c (m2_printstr): Expand parameter length to
ULONGEST.
* m2-lang.h (m2_val_print): Expand parameter embedded_offset
to ULONGEST.
* m2-typeprint.c (m2_array): Use pulongest to print
TYPE_LENGTH.
(m2_enum): expand lastval to LONGEST.
* m2-valprint.c (m2_print_long_set): Expand parameter
embedded_offset to LONGEST.
(m2_print_unbounded_array): Likewise.
(m2_print_array_contents): Likewise. Eliminate eltlen and use
TYPE_LENGTH directly.
(m2_val_print): Expand parameter embedded_offset to LONGEST.
Expand i, len, temp_len to ULONGEST. Remove eltlen, use
TYPE_LENGTH directly.
* m32r-tdep.c (m32r_push_dummy_call): Expand len to ULONGEST.
(m32r_extract_return_value): Likewise.
* m68hc11-tdep.c (m68hc11_push_dummy_call): Expand len to
ULONGEST.
(m68hc11_store_return_value): Likewise.
* m68k-tdep.c (m68k_extract_return_value): Expand len to
ULONGEST. Use pulongest to format print len.
(m68k_svr4_extract_return_value): Replace single-use variable
len with TYPE_LENGTH.
(m68k_store_return_value): Expand len to ULONGEST. Use pulongest
to format print len.
(m68k_svr4_store_return_value): Replace single-use variable len
with TYPE_LENGTH.
(m68k_push_dummy_call): Expand len, container_len, offset to
ULONGEST.
* m88k-tdep.c (m88k_store_arguments): Expand
num_register_words, num_stack_words, len to ULONGEST.
(m88k_return_value): Expand len to ULONGEST.
* memrange.c (mem_ranges_overlap): Expand parameters len1,
len2 to ULONGEST.
* memrange.h (struct mem_range): Expand member length to
ULONGEST.
(mem_ranges_overlap): Expand parameters len1, len2 to ULONGEST.
* mep-tdep.c (push_large_arguments): Expand arg_len to
ULONGEST.
(mep_push_dummy_call): Expand arg_size to ULONGEST.
* microblaze-tdep.c (microblaze_store_return_value): Expand
len to ULONGEST.
* mips-tdep.c (mips_xfer_register): Expand parameter
buf_offset to LONGEST. Use plongest to format print buf_offset.
(mips_eabi_push_dummy_call): Expand len to ULONGEST. Use
pulongest to format print len.
(mips_n32n64_fp_arg_chunk_p): Expand parameter offset to
LONGEST. Expand pos to LONGEST.
(mips_n32n64_return_value): Expand offset to LONGEST. Use
plongest to format print offset.
(mips_o32_push_dummy_call): Expand len to ULONGEST. Eliminate
single-use variable arglen. Use pulongest to format print len.
(mips_o64_push_dummy_call): Expand len, stack_offset to
ULONGEST. Eliminate single-use variable arglen. use pulongest
to format print len.
* mn10300-tdep.c (mn10300_type_align): Return ULONGEST.
Expand align, falign to ULONGEST.
(mn10300_push_dummy_call): Expand len, arg_len to ULONGEST.
* moxie-tdep.c (moxie_store_return_value): Expand len to
ULONGEST.
(moxie_extract_return_value): Likewise.
* mt-tdep.c (mt_push_dummy_call): Expand stack_dest, typelen
to ULONGEST.
* objc-lang.c (objc_printstr): Expand parameter length to
ULONGEST.
* opencl-lang.c (lookup_opencl_vector_type): Expand parameter
el_length to ULONGEST. Expand length to ULONGEST.
(lval_func_read): Expand offset, n, i, j to LONGEST. Expand
elsize to ULONGEST.
(lval_func_write): Likewise.
(lval_func_check_validity): Expand parameter length to ULONGEST.
Expand elsize to ULONGEST. Expand start, end, i to LONGEST.
(lval_func_check_any_valid): Expand elsize to ULONGEST.
(lval_func_check_synthetic_pointer): Expand parameter offset to
LONGEST. Expand parameter length to ULONGEST. Expand elsize to
ULONGEST. Expand start, end, i to LONGEST.
* p-lang.c (is_pascal_string_type): Expand parameter
length_pos, string_pos to LONGEST *. Expand parameter
length_size to ULONGEST *.
(pascal_printstr): Expand parameter length to ULONGEST.
* p-lang.h (pascal_val_print): Expand parameter
embedded_offset to LONGEST.
(is_pascal_string_type): Expand parameter length_pos, string_pos
to LONGEST *. Expand parameter length_size to ULONGEST *.
(pascal_printstr): Expand parameter length to ULONGEST.
(pascal_object_print_value_fields): Expand parameter offset to
LONGEST.
* p-typeprint.c (pascal_type_print_base): Expand lastval to
LONGEST.
* p-valprint.c (pascal_val_print): Expand parameter
embedded_offset to LONGEST. Expand eltlen, length_size to
ULONGEST. Expand length_pos, string_pos to LONGEST.
(pascal_object_print_value_fields): Expand parameter offset to
LONGEST.
(pascal_object_print_value): Likewise. Expand boffset,
thisoffset to LONGEST.
* ppc-linux-nat.c (check_condition): Expand parameter len to
ULONGEST *.
* ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call): Expand
argoffset, structoffset, len, i, nelt to ULONGEST.
(do_ppc_sysv_return_value): Expand i, nelt, offset to ULONGEST.
(ppc64_sysv_abi_push_dummy_call): Expand len to ULONGEST.
(ppc64_sysv_abi_return_value): Expand n_regs, i, offset to
ULONGEST.
* printcmd.c (print_formatted): Expand len to ULONGEST.
(float_type_from_length): Likewise.
(print_scalar_formatted): Likewise.
* python/py-prettyprint.c (apply_val_pretty_printer): Expand
parameter embedded_offset to LONGEST.
* python/python.h (apply_val_pretty_printer): Likewise.
* regcache.c (regcache_xfer_part): Expand parameter offset to
LONGEST.
(regcache_cooked_read_part): Likewise.
(regcache_cooked_write_part): Likewise.
* regcache.h (regcache_cooked_read_part): Likewise.
(regcache_cooked_write_part): Likewise.
* remote.c (remote_write_bytes_aux): Expand parameter len to
LONGEST.
(remote_write_bytes): Likewise.
(remote_region_ok_for_hw_watchpoint): Likewise.
* rl78-tdep.c (rl78_push_dummy_call): Expand len,
container_len to ULONGEST.
* rs6000-aix-tdep.c (rs6000_push_dummy_call): Expand len to
ULONGEST.
(ran_out_of_registers_for_arguments): Expand space, jj to
ULONGEST.
* s390-tdep.c (s390_value_from_register): Eliminate single use
variable len.
(s390_function_arg_pass_by_reference): Likewise.
(s390_function_arg_float): Eliminate single-use variable length.
(s390_push_dummy_call): Likewise. Expand length to ULONGEST.
(s390_frame_align): Eliminate single-us variable length.
(s390_return_value): Expand length to ULONGEST.
* score-tdep.c (score_push_dummy_call): Expand arglen to
ULONGEST.
* sh-tdep.c (sh_extract_return_value_nofpu): Epand len to
ULONGEST.
(sh_store_return_value_nofpu): Likewise.
* sh64-tdep.c (sh64_push_dummy_call): Expand stack_offset,
stack_alloc, len to ULONGEST.
(sh64_extract_return_value): Expand len to ULONGEST.
(sh64_store_return_value): Likewise.
* sparc-tdep.c (sparc32_store_arguments): Likewise.
* sparc64-tdep.c (sparc64_store_floating_fields): Expand
parameter bitpos to LONGEST. Expand subpos to LONGEST.
(sparc64_extract_floating_fields): Likewise.
(sparc64_store_arguments): Expand len to ULONGEST.
* spu-tdep.c (spu_value_from_register): Likewise.
* stack.c (read_frame_arg): Expand len, len_deref to ULONGEST.
(print_frame_args): Expand current_offset, arg_size to ULONGEST.
* symfile-mem.c (symfile_target_read_memory): New
function. Wrap around target_read_memory.
(symbol_file_add_from_memory): Use symfile_target_read_memory.
* symmisc.c (print_symbol): Expand i to ULONGEST. Use
pulongest to format print TYPE_LENGTH.
* target.c (target_read_memory): Expand parameter len to
LONGEST.
(target_read_stack): Likewise.
(target_write_memory): Likewise.
(target_write_raw_memory): Likewise.
(default_region_ok_for_hw_watchpoint): Likewise.
(debug_to_region_ok_for_hw_watchpoint): Likewise.
* target.h (struct target_ops): Expand parameter len to
LONGEST for to_region_ok_for_hw_watchpoint.
(target_read_memory): Expand parameter len to LONGEST.
(target_read_stack): Likewise.
(target_write_memory): Likewise.
(target_write_raw_memory): Likewise.
* tracepoint.c (collect_symbol): Expand len to ULONGEST.
(encode_actions_1): Make addr as CORE_ADDR. Expand len to
ULONGEST.
(scope_info): Expand j to ULONGEST. Use pulongest to format
print TYPE_LENGTH.
* typeprint.c (whatis_exp): Expand top to LONGEST.
* v850-tdep.c (v850_push_dummy_call): Expand len to ULONGEST.
(v850_extract_return_value): Expand len to LONGEST.
(v850_store_return_value): Expand len to ULONGEST.
* valarith.c (value_subscripted_rvalue): Expand elt_size,
elt_offs to ULONGEST.
(value_binop): Expand len to LONGEST.
(value_logical_not): Expand len1, len2 to LONGEST.
* valops.c (value_allocate_space_in_inferior): Expand
parameter len to ULONGEST. Use value_from_ulongest to get the
value for len.
(value_cast_structs): Expand top to LONGEST.
(value_cast): Expand val_length, element_length to ULONGEST.
(dynamic_cast_check_1): Expand parameter embedded_offset to
LONGEST. Expand offset to LONGEST.
(dynamic_cast_check_2): Likewise.
(value_dynamic_cast): Expand top to LONGEST.
(value_fetch_lazy): Expand length to ULONGEST.
(read_value_memory): Expand parameter length to ULONGEST.
(value_assign): Expand changed_len to ULONGEST. Expand offset to
LONGEST.
(value_array): Expand typelength to ULONGEST.
(search_struct_field): Expand parameter offset to LONGEST.
Expand new_offset, boffset to LONGEST.
(search_struct_method): Expand parameter offset to LONGEST.
Expand base_offset, this_offset to LONGEST.
(find_method_list): Expand parameter offset to LONGEST,
parameter boffset to LONGEST *. Expand base_offset to LONGEST.
(value_find_oload_method_list): Expand parameter boffset to
LONGEST *.
(find_overload_match): Expand boffset to LONGEST.
(value_struct_elt_for_reference): Expand parameter offset to
LONGEST. Expand base_offset to LONGEST.
(value_rtti_indirect_type): Expand parameter top to LONGEST *.
(value_full_object): Expand parameter xtop to LONGEST. Expand
top to LONGEST.
* valprint.c (valprint_check_validity): Expand parameter
embedded_offset to LONGEST.
(generic_val_print): Likewise.
(val_print): Likewise.
(val_print_scalar_formatted): Likewise.
(print_hex_chars): Expand parameter len to ULONGEST.
(val_print_array_elements): Expand parameter embedded_offset to
LONGEST. Expand len, eltlen to ULONGEST.
(generic_printstr): Expand parameter length to ULONGEST.
* valprint.h (val_print_array_elements): Expand parameter
embedded_offset to LONGEST.
(val_print_scalar_formatted): Likewise.
(print_hex_chars): Expand parameter len to ULONGEST.
(generic_val_print): Expand parameter embedded_offset to
LONGEST. (generic_printstr): Expand parameter length to
ULONGEST.
* value.c (struct range): Expand member offset to LONGEST.
Expand member length to ULONGEST.
(ranges_overlap): Expand parameters offset1, offset2 to LONGEST.
Expand parameters len1, len2 to ULONGEST.
(range_contain): Expand parameter offset to LONGEST. Expand
parameter length to ULONGEST.
(struct value): Expand members offset, embedded_offset,
pointed_to_offset to LONGEST.
(value_bytes_available): Expand parameter offset to LONGEST,
parameter length to ULONGEST.
(mark_value_bytes_unavailable): Likewise.
(find_first_range_overlap): Likewise.
(value_available_contents_eq): Expand parameters offset1,
offset2 to LONGEST. Expand parameter length to ULONGEST.
(value_offset): Return LONGEST.
(set_value_offset): Expand parameter offset to LONGEST.
(value_contents_copy_raw): Expand parameters src_offset,
dst_offset to LONGEST. Expand parameters length to ULONGEST.
(value_contents_copy): Likewise.
(value_contents_equal): Expand len to ULONGEST.
(value_bits_valid): Expand parameter offset to LONGEST, length
to ULONGEST.
(value_bits_synthetic_pointer): Likewise.
(value_embedded_offset): Return LONGEST.
(set_value_embedded_offset): Expand parameter val to LONGEST.
(value_pointed_to_offset): Return LONGEST.
(set_value_pointed_to_offset): Expand parameter val to LONGEST.
(set_internalvar_component): Expand parameter offset to LONGEST.
(value_primitive_field): Likewise. Expand bitpos, boffset to
LONGEST, container_bitpos to ULONGEST.
(value_fn_field): Expand parameter offset to LONGEST.
(unpack_value_bits_as_long_1): Expand parameters
embedded_offset, bitpos to LONGEST. Expand read_offset to
LONGEST. (unpack_value_bits_as_long): Expand parameter
embeded_offset to LONGEST.
(unpack_value_field_as_long_1): Likewise. Expand bitpos to
LONGEST.
(unpack_value_field_as_long): Expand parameter embedded_offset
to LONGEST.
(value_field_bitfield): Likewise.
(modify_field): Expand parameter bitpos to LONGEST. Expand
bytesize to ULONGEST.
* value.h (value_offset): Return LONGEST.
(set_value_offset): Expand parameter offset to LONGEST.
(value_pointed_to_offset): Return LONGEST.
(set_value_pointed_to_offset): Expand parameter val to LONGEST.
(value_embedded_offset): Return LONGEST.
(set_value_embedded_offset): Expand parameter val to LONGEST.
(struct lval_funcs): Expand parameter offset to LONGEST, length
to ULONGEST for check_validity. Likewise for
check_synthetic_pointer.
(valprint_check_validity): Expand parameter embedded_offset to
LONGEST.
(value_bits_valid): Expand parameter offset to LONGEST, length
to ULONGEST.
(value_bits_synthetic_pointer): Likewise.
(mark_value_bytes_unavailable): Expand parameter offset to
LONGEST, parameter length to ULONGEST.
(value_available_contents_eq): Expand parameters offset1,
offset2 to LONGEST. Expand parameter length to ULONGEST.
(read_value_memory): Expand parameter length to ULONGEST.
(unpack_value_bits_as_long): Expand parameter embeded_offset to
LONGEST.
(unpack_value_field_as_long): Likewise.
(value_field_bitfield): Likewise.
(value_contents_copy_raw): Expand parameters src_offset,
dst_offset to LONGEST. Expand parameters length to ULONGEST.
(value_contents_copy): Likewise.
(value_find_oload_method_list): Expand parameter boffset to
LONGEST *.
(value_primitive_field): Expand parameter offset to LONGEST.
(value_rtti_indirect_type): Expand parameter top to LONGEST *.
(value_full_object): Expand parameter xtop to LONGEST.
(set_internalvar_component): Expand parameter offset to LONGEST.
(value_fn_field): Expand parameter offset to LONGEST.
(modify_field): Expand parameter bitpos to LONGEST.
(val_print): Expand parameter embedded_offset to LONGEST.
(value_allocate_space_in_inferior): Expand parameter len to
ULONGEST.
* vax-tdep.c (vax_store_arguments): Expand count, len to
ULONGEST.
(vax_return_value): Expand len to ULONGEST.
* xstormy16-tdep.c (xstormy16_extract_return_value): Expand
len, i to ULONGEST.
(xstormy16_store_return_value): Likewise.
(xstormy16_push_dummy_call): Expand j to LONGEST, typelen to
ULONGEST.
(xstormy16_push_dummy_call):
* xtensa-tdep.c (xtensa_extract_return_value): Expand len to
ULONGEST. Use pulongest to format print len.
(xtensa_store_return_value): Likewise.
(xtensa_push_dummy_call): Expand size, onstack_size, length to
ULONGEST. Expand offset to LONGEST. Use pulongest to format
print TYPE_LENGTH.

testsuite/ChangeLog:

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

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

[-- Attachment #2: bitpos-expand.patch --]
[-- Type: text/x-patch, Size: 207721 bytes --]

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 180fadb..4417cf1 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -80,7 +80,7 @@ static struct type *desc_bounds_type (struct type *);

static struct value *desc_bounds (struct value *);

-static int fat_pntr_bounds_bitpos (struct type *);
+static LONGEST fat_pntr_bounds_bitpos (struct type *);

static int fat_pntr_bounds_bitsize (struct type *);

@@ -88,13 +88,13 @@ static struct type *desc_data_target_type (struct type *);

static struct value *desc_data (struct value *);

-static int fat_pntr_data_bitpos (struct type *);
+static LONGEST fat_pntr_data_bitpos (struct type *);

static int fat_pntr_data_bitsize (struct type *);

static struct value *desc_one_bound (struct value *, int, int);

-static int desc_bound_bitpos (struct type *, int, int);
+static LONGEST desc_bound_bitpos (struct type *, int, int);

static int desc_bound_bitsize (struct type *, int, int);

@@ -174,7 +174,7 @@ static struct type *static_unwrap_type (struct type *type);

static struct value *unwrap_value (struct value *);

-static struct type *constrained_packed_array_type (struct type *, long *);
+static struct type *constrained_packed_array_type (struct type *, ULONGEST *);

static struct type *decode_constrained_packed_array_type (struct type *);

@@ -189,7 +189,8 @@ static int ada_is_unconstrained_packed_array_type (struct type *);
static struct value *value_subscript_packed (struct value *, int,
struct value **);

-static void move_bits (gdb_byte *, int, const gdb_byte *, int, int, int);
+static void move_bits (gdb_byte *, int, const gdb_byte *, ULONGEST, ULONGEST,
+ int);

static struct value *coerce_unspec_val_to_type (struct value *,
struct type *);
@@ -217,14 +218,14 @@ static struct value *value_val_atr (struct type *, struct value *);
static struct symbol *standard_lookup (const char *, const struct block *,
domain_enum);

-static struct value *ada_search_struct_field (char *, struct value *, int,
+static struct value *ada_search_struct_field (char *, struct value *, LONGEST,
struct type *);

-static struct value *ada_value_primitive_field (struct value *, int, int,
+static struct value *ada_value_primitive_field (struct value *, LONGEST, int,
struct type *);

-static int find_struct_field (const char *, struct type *, int,
- struct type **, int *, int *, int *, int *);
+static int find_struct_field (const char *, struct type *, LONGEST,
+ struct type **, LONGEST *, int *, int *, int *);

static struct value *ada_to_fixed_value_create (struct type *, CORE_ADDR,
struct value *);
@@ -240,7 +241,7 @@ static void ada_language_arch_info (struct gdbarch *,

static void check_size (const struct type *);

-static struct value *ada_index_struct_field (int, struct value *, int,
+static struct value *ada_index_struct_field (LONGEST, struct value *, LONGEST,
struct type *);

static struct value *assign_aggregate (struct value *, struct value *,
@@ -586,7 +587,7 @@ coerce_unspec_val_to_type (struct value *val, struct type *type)
}

static const gdb_byte *
-cond_offset_host (const gdb_byte *valaddr, long offset)
+cond_offset_host (const gdb_byte *valaddr, LONGEST offset)
{
if (valaddr == NULL)
return NULL;
@@ -595,7 +596,7 @@ cond_offset_host (const gdb_byte *valaddr, long offset)
}

static CORE_ADDR
-cond_offset_target (CORE_ADDR address, long offset)
+cond_offset_target (CORE_ADDR address, LONGEST offset)
{
if (address == 0)
return 0;
@@ -1601,7 +1602,7 @@ desc_bounds (struct value *arr)
/* If TYPE is the type of an array-descriptor (fat pointer), the bit
position of the field containing the address of the bounds data. */

-static int
+static LONGEST
fat_pntr_bounds_bitpos (struct type *type)
{
return TYPE_FIELD_BITPOS (desc_base_type (type), 1);
@@ -1667,7 +1668,7 @@ desc_data (struct value *arr)
/* If TYPE is the type of an array-descriptor (fat pointer), the bit
position of the field containing the address of the data. */

-static int
+static LONGEST
fat_pntr_data_bitpos (struct type *type)
{
return TYPE_FIELD_BITPOS (desc_base_type (type), 0);
@@ -1702,7 +1703,7 @@ desc_one_bound (struct value *bounds, int i, int which)
of the Ith lower bound stored in it, if WHICH is 0, and the Ith upper
bound, if WHICH is 1. The first bound is I=1. */

-static int
+static LONGEST
desc_bound_bitpos (struct type *type, int i, int which)
{
return TYPE_FIELD_BITPOS (desc_base_type (type), 2 * i + which - 2);
@@ -1892,7 +1893,7 @@ ada_type_of_array (struct value *arr, int bounds)
zero, and does not need to be recomputed. */
if (lo < hi)
{
- int array_bitsize =
+ ULONGEST array_bitsize =
(hi - lo + 1) * TYPE_FIELD_BITSIZE (elt_type, 0);

TYPE_LENGTH (array_type) = (array_bitsize + 7) / 8;
@@ -2044,7 +2045,7 @@ decode_packed_array_bitsize (struct type *type)
in bits. */

static struct type *
-constrained_packed_array_type (struct type *type, long *elt_bits)
+constrained_packed_array_type (struct type *type, ULONGEST *elt_bits)
{
struct type *new_elt_type;
struct type *new_type;
@@ -2096,7 +2097,7 @@ decode_constrained_packed_array_type (struct type *type)
char *name;
const char *tail;
struct type *shadow_type;
- long bits;
+ ULONGEST bits;

if (!raw_name)
raw_name = ada_type_name (desc_base_type (type));
@@ -2167,7 +2168,8 @@ decode_constrained_packed_array (struct value *arr)
array with no wrapper. In order to interpret the value through
the (left-justified) packed array type we just built, we must
first left-justify it. */
- int bit_size, bit_pos;
+ int bit_size;
+ LONGEST bit_pos;
ULONGEST mod;

mod = ada_modulus (value_type (arr)) - 1;
@@ -2268,15 +2270,16 @@ has_negatives (struct type *type)

struct value *
ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
- long offset, int bit_offset, int bit_size,
+ LONGEST offset, int bit_offset, int bit_size,
struct type *type)
{
struct value *v;
- int src, /* Index into the source area */
- targ, /* Index into the target area */
- srcBitsLeft, /* Number of source bits left to move */
- nsrc, ntarg, /* Number of source and target bytes */
- unusedLS, /* Number of bits in next significant
+ int src; /* Index into the source area */
+ LONGEST targ; /* Index into the target area */
+ int srcBitsLeft, /* Number of source bits left to move */
+ nsrc; /* Number of source bytes */
+ ULONGEST ntarg; /* Number of target bytes */
+ int unusedLS, /* Number of bits in next significant
byte of source that are unused */
accumSize; /* Number of meaningful bits in accum */
unsigned char *bytes; /* First byte containing data to unpack */
@@ -2426,7 +2429,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
not overlap. */
static void
move_bits (gdb_byte *target, int targ_offset, const gdb_byte *source,
- int src_offset, int n, int bits_big_endian_p)
+ ULONGEST src_offset, ULONGEST n, int bits_big_endian_p)
{
unsigned int accum, mask;
int accum_bits, chunk_size;
@@ -2516,7 +2519,7 @@ ada_value_assign (struct value *toval, struct value *fromval)
{
int len = (value_bitpos (toval)
+ bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
- int from_size;
+ ULONGEST from_size;
char *buffer = (char *) alloca (len);
struct value *val;
CORE_ADDR to_addr = value_address (toval);
@@ -2562,7 +2565,7 @@ value_assign_to_component (struct value *container, struct value *component,
(LONGEST) (value_address (component) - value_address (container));
int bit_offset_in_container =
value_bitpos (component) - value_bitpos (container);
- int bits;
+ ULONGEST bits;

val = value_cast (value_type (component), val);

@@ -4082,7 +4085,7 @@ ensure_lval (struct value *val)
if (VALUE_LVAL (val) == not_lval
|| VALUE_LVAL (val) == lval_internalvar)
{
- int len = TYPE_LENGTH (ada_check_typedef (value_type (val)));
+ ULONGEST len = TYPE_LENGTH (ada_check_typedef (value_type (val)));
const CORE_ADDR addr =
value_as_long (value_allocate_space_in_inferior (len));

@@ -4156,7 +4159,7 @@ static CORE_ADDR
value_pointer (struct value *value, struct type *type)
{
struct gdbarch *gdbarch = get_type_arch (type);
- unsigned len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
gdb_byte *buf = alloca (len);
CORE_ADDR addr;

@@ -6044,7 +6047,7 @@ value_tag_from_contents_and_address (struct type *type,
const gdb_byte *valaddr,
CORE_ADDR address)
{
- int tag_byte_offset;
+ LONGEST tag_byte_offset;
struct type *tag_type;

if (find_struct_field ("_tag", type, 0, &tag_type, &tag_byte_offset,
@@ -6427,7 +6430,7 @@ ada_in_variant (LONGEST val, struct type *type, int field_num)
only in that it can handle packed values of arbitrary type. */

static struct value *
-ada_value_primitive_field (struct value *arg1, int offset, int fieldno,
+ada_value_primitive_field (struct value *arg1, LONGEST offset, int fieldno,
struct type *arg_type)
{
struct type *type;
@@ -6439,12 +6442,13 @@ ada_value_primitive_field (struct value *arg1, int offset, int fieldno,

if (TYPE_FIELD_BITSIZE (arg_type, fieldno) != 0)
{
- int bit_pos = TYPE_FIELD_BITPOS (arg_type, fieldno);
+ LONGEST bit_pos = TYPE_FIELD_BITPOS (arg_type, fieldno);
int bit_size = TYPE_FIELD_BITSIZE (arg_type, fieldno);

return ada_value_primitive_packed_val (arg1, value_contents (arg1),
- offset + bit_pos / 8,
- bit_pos % 8, bit_size, type);
+ offset + bit_pos / 8,
+ bit_pos % 8, bit_size,
+ type);
}
else
return value_primitive_field (arg1, offset, fieldno, arg_type);
@@ -6466,9 +6470,9 @@ ada_value_primitive_field (struct value *arg1, int offset, int fieldno,
Returns 1 if found, 0 otherwise. */

static int
-find_struct_field (const char *name, struct type *type, int offset,
+find_struct_field (const char *name, struct type *type, LONGEST offset,
struct type **field_type_p,
- int *byte_offset_p, int *bit_offset_p, int *bit_size_p,
+ LONGEST *byte_offset_p, int *bit_offset_p, int *bit_size_p,
int *index_p)
{
int i;
@@ -6486,8 +6490,8 @@ find_struct_field (const char *name, struct type *type, int offset,

for (i = 0; i < TYPE_NFIELDS (type); i += 1)
{
- int bit_pos = TYPE_FIELD_BITPOS (type, i);
- int fld_offset = offset + bit_pos / 8;
+ LONGEST bit_pos = TYPE_FIELD_BITPOS (type, i);
+ LONGEST fld_offset = offset + bit_pos / 8;
const char *t_field_name = TYPE_FIELD_NAME (type, i);

if (t_field_name == NULL)
@@ -6557,7 +6561,7 @@ num_visible_fields (struct type *type)
Searches recursively through wrapper fields (e.g., '_parent'). */

static struct value *
-ada_search_struct_field (char *name, struct value *arg, int offset,
+ada_search_struct_field (char *name, struct value *arg, LONGEST offset,
struct type *type)
{
int i;
@@ -6590,7 +6594,7 @@ ada_search_struct_field (char *name, struct value *arg, int offset,
int j;
struct type *field_type = ada_check_typedef (TYPE_FIELD_TYPE (type,
i));
- int var_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
+ LONGEST var_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;

for (j = 0; j < TYPE_NFIELDS (field_type); j += 1)
{
@@ -6608,8 +6612,8 @@ ada_search_struct_field (char *name, struct value *arg, int offset,
return NULL;
}

-static struct value *ada_index_struct_field_1 (int *, struct value *,
- int, struct type *);
+static struct value *ada_index_struct_field_1 (LONGEST *, struct value *,
+ LONGEST, struct type *);

/* Return field #INDEX in ARG, where the index is that returned by
@@ -6618,7 +6622,7 @@ static struct value *ada_index_struct_field_1 (int *, struct value *,
* If found, return value, else return NULL. */

static struct value *
-ada_index_struct_field (int index, struct value *arg, int offset,
+ada_index_struct_field (LONGEST index, struct value *arg, LONGEST offset,
struct type *type)
{
return ada_index_struct_field_1 (&index, arg, offset, type);
@@ -6630,7 +6634,7 @@ ada_index_struct_field (int index, struct value *arg, int offset,
* *INDEX_P. */

static struct value *
-ada_index_struct_field_1 (int *index_p, struct value *arg, int offset,
+ada_index_struct_field_1 (LONGEST *index_p, struct value *arg, LONGEST offset,
struct type *type)
{
int i;
@@ -6720,7 +6724,8 @@ ada_value_struct_elt (struct value *arg, char *name, int no_err)
v = ada_search_struct_field (name, arg, 0, t);
else
{
- int bit_offset, bit_size, byte_offset;
+ int bit_offset, bit_size;
+ LONGEST byte_offset;
struct type *field_type;
CORE_ADDR address;

@@ -7026,8 +7031,8 @@ ada_coerce_ref (struct value *val0)
/* Return OFF rounded upward if necessary to a multiple of
ALIGNMENT (a power of 2). */

-static unsigned int
-align_value (unsigned int off, unsigned int alignment)
+static ULONGEST
+align_value (LONGEST off, ULONGEST alignment)
{
return (off + alignment - 1) & ~(alignment - 1);
}
@@ -7406,10 +7411,10 @@ ada_template_to_fixed_record_type_1 (struct type *type,
struct value *mark = value_mark ();
struct value *dval;
struct type *rtype;
- int nfields, bit_len;
+ int nfields;
int variant_field;
- long off;
- int fld_bit_len;
+ ULONGEST off, bit_len;
+ ULONGEST fld_bit_len;
int f;

/* Compute the number of fields in this record type that are going
@@ -7480,7 +7485,7 @@ ada_template_to_fixed_record_type_1 (struct type *type,
that follow this one. */
if (ada_is_aligner_type (field_type))
{
- long field_offset = TYPE_FIELD_BITPOS (field_type, f);
+ LONGEST field_offset = TYPE_FIELD_BITPOS (field_type, f);

field_valaddr = cond_offset_host (field_valaddr, field_offset);
field_address = cond_offset_target (field_address, field_offset);
@@ -7599,11 +7604,11 @@ ada_template_to_fixed_record_type_1 (struct type *type,
if (TYPE_LENGTH (type) <= 0)
{
if (TYPE_NAME (rtype))
- warning (_("Invalid type size for `%s' detected: %d."),
- TYPE_NAME (rtype), TYPE_LENGTH (type));
+ warning (_("Invalid type size for `%s' detected: %s."),
+ TYPE_NAME (rtype), pulongest (TYPE_LENGTH (type)));
else
- warning (_("Invalid type size for <unnamed> detected: %d."),
- TYPE_LENGTH (type));
+ warning (_("Invalid type size for <unnamed> detected: %s."),
+ pulongest (TYPE_LENGTH (type)));
}
else
{
@@ -7940,7 +7945,8 @@ to_fixed_array_type (struct type *type0, struct value *dval,
type was a regular (non-packed) array type. As a result, the
bitsize of the array elements needs to be set again, and the array
length needs to be recomputed based on that bitsize. */
- int len = TYPE_LENGTH (result) / TYPE_LENGTH (TYPE_TARGET_TYPE (result));
+ ULONGEST len = TYPE_LENGTH (result) /
+ TYPE_LENGTH (TYPE_TARGET_TYPE (result));
int elt_bitsize = TYPE_FIELD_BITSIZE (type0, 0);

TYPE_FIELD_BITSIZE (result, 0) = TYPE_FIELD_BITSIZE (type0, 0);
diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h
index 9a93c50..3de0723 100644
--- a/gdb/ada-lang.h
+++ b/gdb/ada-lang.h
@@ -168,7 +168,7 @@ extern void ada_print_type (struct type *, const char *, struct ui_file *, int,
extern void ada_print_typedef (struct type *type, struct symbol *new_symbol,
struct ui_file *stream);

-extern void ada_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
+extern void ada_val_print (struct type *, const gdb_byte *, LONGEST, CORE_ADDR,
struct ui_file *, int,
const struct value *,
const struct value_print_options *);
@@ -183,7 +183,7 @@ extern void ada_emit_char (int, struct type *, struct ui_file *, int, int);
extern void ada_printchar (int, struct type *, struct ui_file *);

extern void ada_printstr (struct ui_file *, struct type *, const gdb_byte *,
- unsigned int, const char *, int,
+ ULONGEST, const char *, int,
const struct value_print_options *);

struct value *ada_convert_actual (struct value *actual,
@@ -257,7 +257,7 @@ extern int ada_is_constrained_packed_array_type (struct type *);

extern struct value *ada_value_primitive_packed_val (struct value *,
const gdb_byte *,
- long, int, int,
+ LONGEST, int, int,
struct type *);

extern struct type *ada_coerce_to_simple_array_type (struct type *);
diff --git a/gdb/ada-typeprint.c b/gdb/ada-typeprint.c
index 40f3058..2a1852c 100644
--- a/gdb/ada-typeprint.c
+++ b/gdb/ada-typeprint.c
@@ -815,8 +815,8 @@ ada_print_type (struct type *type0, const char *varstring,
const char *name = ada_type_name (type);

if (!ada_is_range_type_name (name))
- fprintf_filtered (stream, _("<%d-byte integer>"),
- TYPE_LENGTH (type));
+ fprintf_filtered (stream, _("<%s-byte integer>"),
+ pulongest (TYPE_LENGTH (type)));
else
{
fprintf_filtered (stream, "range ");
@@ -837,7 +837,8 @@ ada_print_type (struct type *type0, const char *varstring,
}
break;
case TYPE_CODE_FLT:
- fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
+ fprintf_filtered (stream, _("<%s-byte float>"),
+ pulongest (TYPE_LENGTH (type)));
break;
case TYPE_CODE_ENUM:
if (show < 0)
diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 95ec7ec..245fd41 100644
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -42,19 +42,18 @@ static void print_record (struct type *, const gdb_byte *, int,
const struct value_print_options *);

static int print_field_values (struct type *, const gdb_byte *,
- int,
+ LONGEST,
struct ui_file *, int,
const struct value *,
const struct value_print_options *,
- int, struct type *, int);
+ int, struct type *, LONGEST);

static void adjust_type_signedness (struct type *);

-static void ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
+static void ada_val_print_1 (struct type *, const gdb_byte *, LONGEST, CORE_ADDR,
struct ui_file *, int,
const struct value *,
const struct value_print_options *);
-\f

/* Make TYPE unsigned if its range of values includes no negatives. */
static void
@@ -144,7 +143,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
unsigned int things_printed = 0;
unsigned len;
struct type *elttype, *index_type;
- unsigned eltlen;
+ ULONGEST eltlen;
unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
struct value *mark = value_mark ();
LONGEST low = 0;
@@ -293,7 +292,7 @@ ada_emit_char (int c, struct type *type, struct ui_file *stream,
of a character. */

static int
-char_at (const gdb_byte *string, int i, int type_len,
+char_at (const gdb_byte *string, ULONGEST i, int type_len,
enum bfd_endian byte_order)
{
if (type_len == 1)
@@ -465,7 +464,7 @@ ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)

static void
printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,
- unsigned int length, int force_ellipses, int type_len,
+ ULONGEST length, int force_ellipses, int type_len,
const struct value_print_options *options)
{
enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (elttype));
@@ -556,7 +555,7 @@ printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,

void
ada_printstr (struct ui_file *stream, struct type *type,
- const gdb_byte *string, unsigned int length,
+ const gdb_byte *string, ULONGEST length,
const char *encoding, int force_ellipses,
const struct value_print_options *options)
{
@@ -570,7 +569,7 @@ ada_printstr (struct ui_file *stream, struct type *type,

void
ada_val_print (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options)
@@ -602,8 +601,8 @@ ada_val_print_array (struct type *type, const gdb_byte *valaddr,
{
enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
struct type *elttype = TYPE_TARGET_TYPE (type);
- unsigned int eltlen;
- unsigned int len;
+ ULONGEST eltlen;
+ ULONGEST len;

/* We know that ELTTYPE cannot possibly be null, because we found
that TYPE is a string-like type. Similarly, the size of ELTTYPE
@@ -621,7 +620,7 @@ ada_val_print_array (struct type *type, const gdb_byte *valaddr,
elements up to it. */
if (options->stop_print_at_null)
{
- int temp_len;
+ ULONGEST temp_len;

/* Look for a NULL char. */
for (temp_len = 0;
@@ -654,7 +653,7 @@ ada_val_print_array (struct type *type, const gdb_byte *valaddr,

static void
ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
- int offset, CORE_ADDR address,
+ LONGEST offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *original_value,
const struct value_print_options *options)
@@ -730,7 +729,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
if (ada_is_fixed_point_type (type))
{
LONGEST v = unpack_long (type, valaddr + offset_aligned);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
(double) ada_fixed_to_float (type, v));
@@ -924,12 +923,12 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr,

static int
print_variant_part (struct type *type, int field_num,
- const gdb_byte *valaddr, int offset,
+ const gdb_byte *valaddr, LONGEST offset,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options,
int comma_needed,
- struct type *outer_type, int outer_offset)
+ struct type *outer_type, LONGEST outer_offset)
{
struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
int which = ada_which_variant_applies (var_type, outer_type,
@@ -1036,11 +1035,11 @@ print_record (struct type *type, const gdb_byte *valaddr,

static int
print_field_values (struct type *type, const gdb_byte *valaddr,
- int offset, struct ui_file *stream, int recurse,
+ LONGEST offset, struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options,
int comma_needed,
- struct type *outer_type, int outer_offset)
+ struct type *outer_type, LONGEST outer_offset)
{
int i, len;

@@ -1121,7 +1120,7 @@ print_field_values (struct type *type, const gdb_byte *valaddr,
}
else
{
- int bit_pos = TYPE_FIELD_BITPOS (type, i);
+ LONGEST bit_pos = TYPE_FIELD_BITPOS (type, i);
int bit_size = TYPE_FIELD_BITSIZE (type, i);
struct value_print_options opts;

diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c
index 856aa0d..8b6a970 100644
--- a/gdb/alpha-tdep.c
+++ b/gdb/alpha-tdep.c
@@ -303,7 +303,7 @@ alpha_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
struct alpha_arg
{
const gdb_byte *contents;
- int len;
+ ULONGEST len;
int offset;
};
struct alpha_arg *alpha_args
@@ -424,7 +424,7 @@ alpha_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
{
const gdb_byte *contents = m_arg->contents;
int offset = m_arg->offset;
- int len = m_arg->len;
+ ULONGEST len = m_arg->len;

/* Copy the bytes destined for registers into arg_reg_buffer. */
if (offset < sizeof(arg_reg_buffer))
@@ -475,7 +475,7 @@ alpha_extract_return_value (struct type *valtype, struct regcache *regcache,
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int length = TYPE_LENGTH (valtype);
+ ULONGEST length = TYPE_LENGTH (valtype);
gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
ULONGEST l;

@@ -544,7 +544,7 @@ alpha_store_return_value (struct type *valtype, struct regcache *regcache,
const gdb_byte *valbuf)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- int length = TYPE_LENGTH (valtype);
+ ULONGEST length = TYPE_LENGTH (valtype);
gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
ULONGEST l;

diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c
index 685fa48..0ec7f99 100644
--- a/gdb/amd64-tdep.c
+++ b/gdb/amd64-tdep.c
@@ -443,7 +443,7 @@ amd64_non_pod_p (struct type *type)
static void
amd64_classify_aggregate (struct type *type, enum amd64_reg_class class[2])
{
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

/* 1. If the size of an object is larger than two eightbytes, or in
C++, is a non-POD structure or union type, or contains
@@ -482,10 +482,10 @@ amd64_classify_aggregate (struct type *type, enum amd64_reg_class class[2])
for (i = 0; i < TYPE_NFIELDS (type); i++)
{
struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
- int pos = TYPE_FIELD_BITPOS (type, i) / 64;
+ LONGEST pos = TYPE_FIELD_BITPOS (type, i) / 64;
enum amd64_reg_class subclass[2];
- int bitsize = TYPE_FIELD_BITSIZE (type, i);
- int endpos;
+ ULONGEST bitsize = TYPE_FIELD_BITSIZE (type, i);
+ LONGEST endpos;

if (bitsize == 0)
bitsize = TYPE_LENGTH (subtype) * 8;
@@ -549,7 +549,7 @@ void
amd64_classify (struct type *type, enum amd64_reg_class class[2])
{
enum type_code code = TYPE_CODE (type);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

class[0] = class[1] = AMD64_NO_CLASS;

@@ -598,7 +598,7 @@ amd64_return_value (struct gdbarch *gdbarch, struct type *func_type,
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
enum amd64_reg_class class[2];
- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);
static int integer_regnum[] = { AMD64_RAX_REGNUM, AMD64_RDX_REGNUM };
static int sse_regnum[] = { AMD64_XMM0_REGNUM, AMD64_XMM1_REGNUM };
int integer_reg = 0;
@@ -727,8 +727,8 @@ amd64_push_arguments (struct regcache *regcache, int nargs,
that register number (or a negative value otherwise). */
int *arg_addr_regno = alloca (nargs * sizeof (int));
int num_stack_args = 0;
- int num_elements = 0;
- int element = 0;
+ ULONGEST num_elements = 0;
+ ULONGEST element = 0;
int integer_reg = 0;
int sse_reg = 0;
int i;
@@ -742,7 +742,7 @@ amd64_push_arguments (struct regcache *regcache, int nargs,
for (i = 0; i < nargs; i++)
{
struct type *type = value_type (args[i]);
- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);
enum amd64_reg_class class[2];
int needed_integer_regs = 0;
int needed_sse_regs = 0;
@@ -836,7 +836,7 @@ amd64_push_arguments (struct regcache *regcache, int nargs,
{
struct type *type = value_type (stack_args[i]);
const gdb_byte *valbuf = value_contents (stack_args[i]);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
CORE_ADDR arg_addr = sp + element * 8;

write_memory (arg_addr, valbuf, len);
@@ -2551,7 +2551,7 @@ amd64_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
CORE_ADDR jb_addr;
struct gdbarch *gdbarch = get_frame_arch (frame);
int jb_pc_offset = gdbarch_tdep (gdbarch)->jb_pc_offset;
- int len = TYPE_LENGTH (builtin_type (gdbarch)->builtin_func_ptr);
+ ULONGEST len = TYPE_LENGTH (builtin_type (gdbarch)->builtin_func_ptr);

/* If JB_PC_OFFSET is -1, we have no way to find out where the
longjmp will land. */
diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c
index 2b94eca..2ec936c 100644
--- a/gdb/amd64-windows-tdep.c
+++ b/gdb/amd64-windows-tdep.c
@@ -77,7 +77,7 @@ amd64_windows_return_value (struct gdbarch *gdbarch, struct type *func_type,
struct type *type, struct regcache *regcache,
gdb_byte *readbuf, const gdb_byte *writebuf)
{
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
int regnum = -1;

/* See if our value is returned through a register. If it is, then
diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index f83dc0e..51eed0c 100644
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -3577,7 +3577,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct value *function,

for (argnum = 0; argnum < nargs; argnum++)
{
- int len;
+ ULONGEST len;
struct type *arg_type;
struct type *target_type;
enum type_code typecode;
@@ -8773,7 +8773,7 @@ arm_extract_return_value (struct type *type, struct regcache *regs,
/* If the type is a plain integer, then the access is
straight-forward. Otherwise we have to play around a bit
more. */
- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);
int regno = ARM_A1_REGNUM;
ULONGEST tmp;

@@ -8795,7 +8795,7 @@ arm_extract_return_value (struct type *type, struct regcache *regs,
/* For a structure or union the behaviour is as if the value had
been stored to word-aligned memory and then loaded into
registers with 32-bit load instruction(s). */
- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);
int regno = ARM_A1_REGNUM;
bfd_byte tmpbuf[INT_REGISTER_SIZE];

@@ -8976,7 +8976,7 @@ arm_store_return_value (struct type *type, struct regcache *regs,
/* Integral values greater than one word are stored in consecutive
registers starting with r0. This will always be a multiple of
the regiser size. */
- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);
int regno = ARM_A1_REGNUM;

while (len > 0)
@@ -8992,7 +8992,7 @@ arm_store_return_value (struct type *type, struct regcache *regs,
/* For a structure or union the behaviour is as if the value had
been stored to word-aligned memory and then loaded into
registers with 32-bit load instruction(s). */
- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);
int regno = ARM_A1_REGNUM;
bfd_byte tmpbuf[INT_REGISTER_SIZE];

diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c
index 34b0baf..c7ba3d8 100644
--- a/gdb/avr-tdep.c
+++ b/gdb/avr-tdep.c
@@ -906,7 +906,7 @@ avr_return_value (struct gdbarch *gdbarch, struct type *func_type,
struct type *valtype, struct regcache *regcache,
gdb_byte *readbuf, const gdb_byte *writebuf)
{
- int i;
+ ULONGEST i;
/* Single byte are returned in r24.
Otherwise, the MSB of the return value is always in r25, calculate which
register holds the LSB. */
@@ -1177,7 +1177,8 @@ struct stack_item
};

static struct stack_item *
-push_stack_item (struct stack_item *prev, const bfd_byte *contents, int len)
+push_stack_item (struct stack_item *prev, const bfd_byte *contents,
+ ULONGEST len)
{
struct stack_item *si;
si = xmalloc (sizeof (struct stack_item));
@@ -1266,12 +1267,12 @@ avr_push_dummy_call (struct gdbarch *gdbarch, struct value *function,

for (i = 0; i < nargs; i++)
{
- int last_regnum;
+ ULONGEST last_regnum;
int j;
struct value *arg = args[i];
struct type *type = check_typedef (value_type (arg));
const bfd_byte *contents = value_contents (arg);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

/* Calculate the potential last register needed. */
last_regnum = regnum - (len + (len & 1));
diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index 909f282..b1b8071 100644
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -80,12 +80,12 @@ static void gen_traced_pop (struct gdbarch *, struct agent_expr *,
static void gen_sign_extend (struct agent_expr *, struct type *);
static void gen_extend (struct agent_expr *, struct type *);
static void gen_fetch (struct agent_expr *, struct type *);
-static void gen_left_shift (struct agent_expr *, int);
+static void gen_left_shift (struct agent_expr *, LONGEST);

static void gen_frame_args_address (struct gdbarch *, struct agent_expr *);
static void gen_frame_locals_address (struct gdbarch *, struct agent_expr *);
-static void gen_offset (struct agent_expr *ax, int offset);
+static void gen_offset (struct agent_expr *ax, LONGEST offset);
static void gen_sym_offset (struct agent_expr *, struct symbol *);
static void gen_var_ref (struct gdbarch *, struct agent_expr *ax,
struct axs_value *value, struct symbol *var);
@@ -133,15 +133,16 @@ static void gen_deref (struct agent_expr *, struct axs_value *);
static void gen_address_of (struct agent_expr *, struct axs_value *);
static void gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
struct axs_value *value,
- struct type *type, int start, int end);
+ struct type *type, LONGEST start, LONGEST end);
static void gen_primitive_field (struct expression *exp,
struct agent_expr *ax,
struct axs_value *value,
- int offset, int fieldno, struct type *type);
+ LONGEST offset, int fieldno,
+ struct type *type);
static int gen_struct_ref_recursive (struct expression *exp,
struct agent_expr *ax,
struct axs_value *value,
- char *field, int offset,
+ char *field, LONGEST offset,
struct type *type);
static void gen_struct_ref (struct expression *exp, struct agent_expr *ax,
struct axs_value *value,
@@ -363,7 +364,7 @@ gen_trace_static_fields (struct gdbarch *gdbarch,
{
case axs_lvalue_memory:
{
- int length = TYPE_LENGTH (check_typedef (value.type));
+ ULONGEST length = TYPE_LENGTH (check_typedef (value.type));

ax_const_l (ax, length);
ax_simple (ax, aop_trace);
@@ -421,7 +422,7 @@ gen_traced_pop (struct gdbarch *gdbarch,

case axs_lvalue_memory:
{
- int length = TYPE_LENGTH (check_typedef (value->type));
+ ULONGEST length = TYPE_LENGTH (check_typedef (value->type));

if (string_trace)
ax_simple (ax, aop_dup);
@@ -565,7 +566,7 @@ gen_fetch (struct agent_expr *ax, struct type *type)
right shift it by -DISTANCE bits if DISTANCE < 0. This generates
unsigned (logical) right shifts. */
static void
-gen_left_shift (struct agent_expr *ax, int distance)
+gen_left_shift (struct agent_expr *ax, LONGEST distance)
{
if (distance > 0)
{
@@ -619,7 +620,7 @@ gen_frame_locals_address (struct gdbarch *gdbarch, struct agent_expr *ax)
programming in ML, it would be clearer why these are the same
thing. */
static void
-gen_offset (struct agent_expr *ax, int offset)
+gen_offset (struct agent_expr *ax, LONGEST offset)
{
/* It would suffice to simply push the offset and add it, but this
makes it easier to read positive and negative offsets in the
@@ -1275,7 +1276,7 @@ gen_address_of (struct agent_expr *ax, struct axs_value *value)
static void
gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
struct axs_value *value, struct type *type,
- int start, int end)
+ LONGEST start, LONGEST end)
{
/* Note that ops[i] fetches 8 << i bits. */
static enum agent_op ops[]
@@ -1310,13 +1311,13 @@ gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,

/* The first and one-after-last bits in the field, but rounded down
and up to byte boundaries. */
- int bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT;
- int bound_end = (((end + TARGET_CHAR_BIT - 1)
- / TARGET_CHAR_BIT)
- * TARGET_CHAR_BIT);
+ LONGEST bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT;
+ LONGEST bound_end = (((end + TARGET_CHAR_BIT - 1)
+ / TARGET_CHAR_BIT)
+ * TARGET_CHAR_BIT);

/* current bit offset within the structure */
- int offset;
+ LONGEST offset;

/* The index in ops of the opcode we're considering. */
int op;
@@ -1435,7 +1436,7 @@ gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
static void
gen_primitive_field (struct expression *exp,
struct agent_expr *ax, struct axs_value *value,
- int offset, int fieldno, struct type *type)
+ LONGEST offset, int fieldno, struct type *type)
{
/* Is this a bitfield? */
if (TYPE_FIELD_PACKED (type, fieldno))
@@ -1460,7 +1461,7 @@ gen_primitive_field (struct expression *exp,
static int
gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
struct axs_value *value,
- char *field, int offset, struct type *type)
+ char *field, LONGEST offset, struct type *type)
{
int i, rslt;
int nbases = TYPE_N_BASECLASSES (type);
diff --git a/gdb/bfin-tdep.c b/gdb/bfin-tdep.c
index a48758d..e5eef86 100644
--- a/gdb/bfin-tdep.c
+++ b/gdb/bfin-tdep.c
@@ -506,14 +506,14 @@ bfin_push_dummy_call (struct gdbarch *gdbarch,
char buf[4];
int i;
long reg_r0, reg_r1, reg_r2;
- int total_len = 0;
+ ULONGEST total_len = 0;
enum bfin_abi abi = bfin_abi (gdbarch);
CORE_ADDR func_addr = find_function_addr (function, NULL);

for (i = nargs - 1; i >= 0; i--)
{
struct type *value_type = value_enclosing_type (args[i]);
- int len = TYPE_LENGTH (value_type);
+ ULONGEST len = TYPE_LENGTH (value_type);

total_len += (len + 3) & ~3;
}
@@ -531,8 +531,8 @@ bfin_push_dummy_call (struct gdbarch *gdbarch,
{
struct type *value_type = value_enclosing_type (args[i]);
struct type *arg_type = check_typedef (value_type);
- int len = TYPE_LENGTH (value_type);
- int container_len = (len + 3) & ~3;
+ ULONGEST len = TYPE_LENGTH (value_type);
+ ULONGEST container_len = (len + 3) & ~3;

sp -= container_len;
write_memory (sp, value_contents_writeable (args[i]), container_len);
@@ -613,7 +613,7 @@ bfin_extract_return_value (struct type *type,
struct gdbarch *gdbarch = get_regcache_arch (regs);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
bfd_byte *valbuf = dst;
- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);
ULONGEST tmp;
int regno = BFIN_R0_REGNUM;

@@ -642,7 +642,7 @@ bfin_store_return_value (struct type *type,
registers starting with R0. This will always be a multiple of
the register size. */

- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);
int regno = BFIN_R0_REGNUM;

gdb_assert (len <= 8);
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index ab5f324..0e61513 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -1747,7 +1747,8 @@ update_watchpoint (struct watchpoint *b, int reparse)
&& TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
{
CORE_ADDR addr;
- int len, type;
+ ULONGEST len;
+ int type;
struct bp_location *loc, **tmp;

addr = value_address (v);
@@ -10495,7 +10496,7 @@ can_use_hardware_watchpoint (struct value *v)
&& TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
{
CORE_ADDR vaddr = value_address (v);
- int len;
+ ULONGEST len;
int num_regs;

len = (target_exact_watchpoints
@@ -14091,7 +14092,7 @@ show_breakpoint_cmd (char *args, int from_tty)
GDB itself. */

static void
-invalidate_bp_value_on_memory_change (CORE_ADDR addr, int len,
+invalidate_bp_value_on_memory_change (CORE_ADDR addr, LONGEST len,
const bfd_byte *data)
{
struct breakpoint *bp;
diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
index d23561a..152aaad 100644
--- a/gdb/breakpoint.h
+++ b/gdb/breakpoint.h
@@ -400,7 +400,7 @@ struct bp_location
/* For hardware watchpoints, the size of the memory region being
watched. For hardware ranged breakpoints, the size of the
breakpoint range. */
- int length;
+ ULONGEST length;

/* Type of hardware watchpoint. */
enum target_hw_bp_type watchpoint_type;
diff --git a/gdb/c-lang.c b/gdb/c-lang.c
index 28dce8d..2064011 100644
--- a/gdb/c-lang.c
+++ b/gdb/c-lang.c
@@ -189,7 +189,7 @@ c_printchar (int c, struct type *type, struct ui_file *stream)

void
c_printstr (struct ui_file *stream, struct type *type,
- const gdb_byte *string, unsigned int length,
+ const gdb_byte *string, ULONGEST length,
const char *user_encoding, int force_ellipses,
const struct value_print_options *options)
{
@@ -202,7 +202,6 @@ c_printstr (struct ui_file *stream, struct type *type,
unsigned int things_printed = 0;
int in_quotes = 0;
int need_comma = 0;
- int width = TYPE_LENGTH (type);
struct obstack wchar_buf, output;
struct cleanup *cleanup;
struct wchar_iterator *iter;
@@ -679,7 +678,7 @@ evaluate_subexp_c (struct type *expect_type, struct expression *exp,
}
else
{
- int i;
+ ULONGEST i;

/* Write the terminating character. */
for (i = 0; i < TYPE_LENGTH (type); ++i)
@@ -688,7 +687,7 @@ evaluate_subexp_c (struct type *expect_type, struct expression *exp,
if (satisfy_expected)
{
LONGEST low_bound, high_bound;
- int element_size = TYPE_LENGTH (type);
+ ULONGEST element_size = TYPE_LENGTH (type);

if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
&low_bound, &high_bound) < 0)
diff --git a/gdb/c-lang.h b/gdb/c-lang.h
index 5cbe34d..c02b8f4 100644
--- a/gdb/c-lang.h
+++ b/gdb/c-lang.h
@@ -72,7 +72,7 @@ extern void c_print_typedef (struct type *,
struct ui_file *);

extern void c_val_print (struct type *, const gdb_byte *,
- int, CORE_ADDR,
+ LONGEST, CORE_ADDR,
struct ui_file *, int,
const struct value *,
const struct value_print_options *);
@@ -92,7 +92,7 @@ extern void c_printchar (int, struct type *, struct ui_file *);
extern void c_printstr (struct ui_file * stream,
struct type *elttype,
const gdb_byte *string,
- unsigned int length,
+ ULONGEST length,
const char *user_encoding,
int force_ellipses,
const struct value_print_options *options);
@@ -118,14 +118,14 @@ extern void cp_print_class_member (const gdb_byte *, struct type *,
struct ui_file *, char *);

extern void cp_print_value_fields (struct type *, struct type *,
- const gdb_byte *, int, CORE_ADDR,
+ const gdb_byte *, LONGEST, CORE_ADDR,
struct ui_file *, int,
const struct value *,
const struct value_print_options *,
struct type **, int);

extern void cp_print_value_fields_rtti (struct type *,
- const gdb_byte *, int, CORE_ADDR,
+ const gdb_byte *, LONGEST, CORE_ADDR,
struct ui_file *, int,
const struct value *,
const struct value_print_options *,
diff --git a/gdb/c-typeprint.c b/gdb/c-typeprint.c
index a5892b5..1fd6b48 100644
--- a/gdb/c-typeprint.c
+++ b/gdb/c-typeprint.c
@@ -625,8 +625,8 @@ c_type_print_varspec_suffix (struct type *type,

fprintf_filtered (stream, "[");
if (get_array_bounds (type, &low_bound, &high_bound))
- fprintf_filtered (stream, "%d",
- (int) (high_bound - low_bound + 1));
+ fprintf_filtered (stream, "%s",
+ pulongest (high_bound - low_bound + 1));
fprintf_filtered (stream, "]");

c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index d1fd56d..620bde4 100644
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -133,7 +133,7 @@ static const struct generic_val_print_decorations c_decorations =

void
c_val_print (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *original_value,
const struct value_print_options *options)
@@ -144,7 +144,7 @@ c_val_print (struct type *type, const gdb_byte *valaddr,
unsigned len;
struct type *elttype, *unresolved_elttype;
struct type *unresolved_type = type;
- unsigned eltlen;
+ ULONGEST eltlen;
LONGEST val;
CORE_ADDR addr;

@@ -346,9 +346,9 @@ c_val_print (struct type *type, const gdb_byte *valaddr,
/* Print vtable entry - we only get here if NOT using
-fvtable_thunks. (Otherwise, look under
TYPE_CODE_PTR.) */
- int offset = (embedded_offset
- + TYPE_FIELD_BITPOS (type,
- VTBL_FNADDR_OFFSET) / 8);
+ LONGEST offset = (embedded_offset
+ + TYPE_FIELD_BITPOS (type,
+ VTBL_FNADDR_OFFSET) / 8);
struct type *field_type = TYPE_FIELD_TYPE (type,
VTBL_FNADDR_OFFSET);
CORE_ADDR addr
@@ -428,7 +428,8 @@ c_value_print (struct value *val, struct ui_file *stream,
const struct value_print_options *options)
{
struct type *type, *real_type, *val_type;
- int full, top, using_enc;
+ int full, using_enc;
+ LONGEST top;
struct value_print_options opts = *options;

opts.deref_ref = 1;
diff --git a/gdb/corefile.c b/gdb/corefile.c
index 986e4f5..ff15eac 100644
--- a/gdb/corefile.c
+++ b/gdb/corefile.c
@@ -213,7 +213,7 @@ memory_error (int status, CORE_ADDR memaddr)
/* Same as target_read_memory, but report an error if can't read. */

void
-read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
+read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len)
{
int status;

@@ -225,7 +225,7 @@ read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
/* Same as target_read_stack, but report an error if can't read. */

void
-read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
+read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len)
{
int status;

@@ -352,7 +352,7 @@ read_memory_typed_address (CORE_ADDR addr, struct type *type)
write. */
void
write_memory (CORE_ADDR memaddr,
- const bfd_byte *myaddr, int len)
+ const bfd_byte *myaddr, ULONGEST len)
{
int status;

diff --git a/gdb/cp-abi.c b/gdb/cp-abi.c
index 16b5356..03f4baf 100644
--- a/gdb/cp-abi.c
+++ b/gdb/cp-abi.c
@@ -68,13 +68,13 @@ is_operator_name (const char *name)
return (*current_cp_abi.is_operator_name) (name);
}

-int
+LONGEST
baseclass_offset (struct type *type, int index, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
const struct value *val)
{
volatile struct gdb_exception ex;
- int res = 0;
+ LONGEST res = 0;

gdb_assert (current_cp_abi.baseclass_offset != NULL);

@@ -98,7 +98,7 @@ baseclass_offset (struct type *type, int index, const gdb_byte *valaddr,
struct value *
value_virtual_fn_field (struct value **arg1p,
struct fn_field *f, int j,
- struct type *type, int offset)
+ struct type *type, LONGEST offset)
{
if ((current_cp_abi.virtual_fn_field) == NULL)
return NULL;
@@ -108,7 +108,7 @@ value_virtual_fn_field (struct value **arg1p,

struct type *
value_rtti_type (struct value *v, int *full,
- int *top, int *using_enc)
+ LONGEST *top, int *using_enc)
{
struct type *ret = NULL;
volatile struct gdb_exception e;
diff --git a/gdb/cp-abi.h b/gdb/cp-abi.h
index 8451450..a34e9fe 100644
--- a/gdb/cp-abi.h
+++ b/gdb/cp-abi.h
@@ -108,7 +108,7 @@ extern struct value *value_virtual_fn_field (struct value **valuep,
struct fn_field *f,
int j,
struct type *type,
- int offset);
+ LONGEST offset);

/* Try to find the run-time type of VALUE, using C++ run-time type
@@ -135,7 +135,7 @@ extern struct value *value_virtual_fn_field (struct value **valuep,
FULL, TOP, and USING_ENC can each be zero, in which case we don't
provide the corresponding piece of information. */
extern struct type *value_rtti_type (struct value *value,
- int *full, int *top,
+ int *full, LONGEST *top,
int *using_enc);

/* Compute the offset of the baseclass which is the INDEXth baseclass
@@ -144,11 +144,11 @@ extern struct type *value_rtti_type (struct value *value,
contents of VAL. The result is the offset of the baseclass value
relative to (the address of)(ARG) + OFFSET. */

-extern int baseclass_offset (struct type *type,
- int index, const gdb_byte *valaddr,
- int embedded_offset,
- CORE_ADDR address,
- const struct value *val);
+extern LONGEST baseclass_offset (struct type *type,
+ int index, const gdb_byte *valaddr,
+ LONGEST embedded_offset,
+ CORE_ADDR address,
+ const struct value *val);

/* Describe the target of a pointer to method. CONTENTS is the byte
pattern representing the pointer to method. TYPE is the pointer to
@@ -204,12 +204,13 @@ struct cp_abi_ops
struct value *(*virtual_fn_field) (struct value **arg1p,
struct fn_field * f,
int j, struct type * type,
- int offset);
+ LONGEST offset);
struct type *(*rtti_type) (struct value *v, int *full,
- int *top, int *using_enc);
- int (*baseclass_offset) (struct type *type, int index,
- const bfd_byte *valaddr, int embedded_offset,
- CORE_ADDR address, const struct value *val);
+ LONGEST *top, int *using_enc);
+ LONGEST (*baseclass_offset) (struct type *type, int index,
+ const bfd_byte *valaddr,
+ LONGEST embedded_offset, CORE_ADDR address,
+ const struct value *val);
void (*print_method_ptr) (const gdb_byte *contents,
struct type *type,
struct ui_file *stream);
diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c
index 7dd13bb..a7b9381 100644
--- a/gdb/cp-valprint.c
+++ b/gdb/cp-valprint.c
@@ -82,7 +82,7 @@ static void cp_print_static_field (struct type *, struct value *,
const struct value_print_options *);

static void cp_print_value (struct type *, struct type *,
- const gdb_byte *, int,
+ const gdb_byte *, LONGEST,
CORE_ADDR, struct ui_file *,
int, const struct value *,
const struct value_print_options *,
@@ -156,7 +156,7 @@ cp_is_vtbl_member (struct type *type)

void
cp_print_value_fields (struct type *type, struct type *real_type,
- const gdb_byte *valaddr, int offset,
+ const gdb_byte *valaddr, LONGEST offset,
CORE_ADDR address, struct ui_file *stream,
int recurse, const struct value *val,
const struct value_print_options *options,
@@ -443,7 +443,7 @@ cp_print_value_fields (struct type *type, struct type *real_type,

void
cp_print_value_fields_rtti (struct type *type,
- const gdb_byte *valaddr, int offset,
+ const gdb_byte *valaddr, LONGEST offset,
CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
@@ -459,7 +459,8 @@ cp_print_value_fields_rtti (struct type *type,
TARGET_CHAR_BIT * TYPE_LENGTH (type)))
{
struct value *value;
- int full, top, using_enc;
+ int full, using_enc;
+ LONGEST top;

/* Ugh, we have to convert back to a value here. */
value = value_from_contents_and_address (type, valaddr + offset,
@@ -483,7 +484,7 @@ cp_print_value_fields_rtti (struct type *type,

static void
cp_print_value (struct type *type, struct type *real_type,
- const gdb_byte *valaddr, int offset,
+ const gdb_byte *valaddr, LONGEST offset,
CORE_ADDR address, struct ui_file *stream,
int recurse, const struct value *val,
const struct value_print_options *options,
@@ -493,7 +494,7 @@ cp_print_value (struct type *type, struct type *real_type,
= (struct type **) obstack_next_free (&dont_print_vb_obstack);
struct obstack tmp_obstack = dont_print_vb_obstack;
int i, n_baseclasses = TYPE_N_BASECLASSES (type);
- int thisoffset;
+ LONGEST thisoffset;
struct type *thistype;

if (dont_print_vb == 0)
@@ -507,7 +508,7 @@ cp_print_value (struct type *type, struct type *real_type,

for (i = 0; i < n_baseclasses; i++)
{
- int boffset = 0;
+ LONGEST boffset = 0;
int skip;
struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
const char *basename = TYPE_NAME (baseclass);
@@ -759,7 +760,7 @@ cp_find_class_member (struct type **domain_p, int *fieldno,
for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
{
LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
- LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i));
+ ULONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i));

if (offset >= bitpos && offset < bitpos + bitsize)
{
diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c
index 34a2594..a0a6734 100644
--- a/gdb/cris-tdep.c
+++ b/gdb/cris-tdep.c
@@ -678,7 +678,7 @@ struct stack_item
};

static struct stack_item *
-push_stack_item (struct stack_item *prev, void *contents, int len)
+push_stack_item (struct stack_item *prev, void *contents, ULONGEST len)
{
struct stack_item *si;
si = xmalloc (sizeof (struct stack_item));
@@ -856,10 +856,10 @@ cris_push_dummy_call (struct gdbarch *gdbarch, struct value *function,

for (argnum = 0; argnum < nargs; argnum++)
{
- int len;
+ ULONGEST len;
char *val;
- int reg_demand;
- int i;
+ ULONGEST reg_demand;
+ ULONGEST i;

len = TYPE_LENGTH (value_type (args[argnum]));
val = (char *) value_contents (args[argnum]);
@@ -1669,7 +1669,7 @@ cris_store_return_value (struct type *type, struct regcache *regcache,
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST val;
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (len <= 4)
{
@@ -1840,7 +1840,7 @@ cris_extract_return_value (struct type *type, struct regcache *regcache,
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST val;
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (len <= 4)
{
diff --git a/gdb/d-lang.h b/gdb/d-lang.h
index f93405a..84b149f 100644
--- a/gdb/d-lang.h
+++ b/gdb/d-lang.h
@@ -25,7 +25,7 @@
extern char *d_demangle (const char *mangled, int options);

extern void d_val_print (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options);
diff --git a/gdb/d-valprint.c b/gdb/d-valprint.c
index 3a8d11d..5d066e7 100644
--- a/gdb/d-valprint.c
+++ b/gdb/d-valprint.c
@@ -29,7 +29,7 @@

static int
dynamic_array_type (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options)
@@ -71,9 +71,9 @@ dynamic_array_type (struct type *type, const gdb_byte *valaddr,

/* Implements the la_val_print routine for language D. */
void
-d_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
- CORE_ADDR address, struct ui_file *stream, int recurse,
- const struct value *val,
+d_val_print (struct type *type, const gdb_byte *valaddr,
+ LONGEST embedded_offset, CORE_ADDR address,
+ struct ui_file *stream, int recurse, const struct value *val,
const struct value_print_options *options)
{
int ret;
diff --git a/gdb/doc/observer.texi b/gdb/doc/observer.texi
index 24233cb..d05ebbe 100644
--- a/gdb/doc/observer.texi
+++ b/gdb/doc/observer.texi
@@ -216,7 +216,7 @@ The inferior @var{inf} has been removed from the list of inferiors.
This method is called immediately before freeing @var{inf}.
@end deftypefun

-@deftypefun void memory_changed (CORE_ADDR @var{addr}, int @var{len}, const bfd_byte *@var{data})
+@deftypefun void memory_changed (CORE_ADDR @var{addr}, LONGEST @var{len}, const bfd_byte *@var{data})
Bytes from @var{data} to @var{data} + @var{len} have been written
to the current inferior at @var{addr}.
@end deftypefun
diff --git a/gdb/doublest.c b/gdb/doublest.c
index c8c9e05..71c27c5 100644
--- a/gdb/doublest.c
+++ b/gdb/doublest.c
@@ -770,7 +770,7 @@ floatformat_from_doublest (const struct floatformat *fmt,
but not passed on by GDB. This should be fixed. */

static const struct floatformat *
-floatformat_from_length (struct gdbarch *gdbarch, int len)
+floatformat_from_length (struct gdbarch *gdbarch, ULONGEST len)
{
const struct floatformat *format;

@@ -798,8 +798,8 @@ floatformat_from_length (struct gdbarch *gdbarch, int len)
else
format = NULL;
if (format == NULL)
- error (_("Unrecognized %d-bit floating-point type."),
- len * TARGET_CHAR_BIT);
+ error (_("Unrecognized %s-bit floating-point type."),
+ pulongest (len * TARGET_CHAR_BIT));
return format;
}

diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index caef546..e83e4d5 100644
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -1334,19 +1334,19 @@ insert_bits (unsigned int datum,
BITS_BIG_ENDIAN is taken directly from gdbarch. */

static void
-copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
- const gdb_byte *source, unsigned int source_offset_bits,
- unsigned int bit_count,
+copy_bitwise (gdb_byte *dest, ULONGEST dest_offset_bits,
+ const gdb_byte *source, ULONGEST source_offset,
+ ULONGEST bit_count,
int bits_big_endian)
{
- unsigned int dest_avail;
+ unsigned int dest_avail, source_offset_bits;
int datum;

/* Reduce everything to byte-size pieces. */
dest += dest_offset_bits / 8;
dest_offset_bits %= 8;
- source += source_offset_bits / 8;
- source_offset_bits %= 8;
+ source += source_offset / 8;
+ source_offset_bits = source_offset % 8;

dest_avail = 8 - dest_offset_bits % 8;

@@ -1384,13 +1384,13 @@ static void
read_pieced_value (struct value *v)
{
int i;
- long offset = 0;
+ LONGEST offset = 0;
ULONGEST bits_to_skip;
gdb_byte *contents;
struct piece_closure *c
= (struct piece_closure *) value_computed_closure (v);
struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
- size_t type_len;
+ ULONGEST type_len;
size_t buffer_size = 0;
char *buffer = NULL;
struct cleanup *cleanup;
@@ -1417,8 +1417,8 @@ read_pieced_value (struct value *v)
for (i = 0; i < c->n_pieces && offset < type_len; i++)
{
struct dwarf_expr_piece *p = &c->pieces[i];
- size_t this_size, this_size_bits;
- long dest_offset_bits, source_offset_bits, source_offset;
+ ULONGEST this_size, this_size_bits;
+ LONGEST dest_offset_bits, source_offset_bits, source_offset;
const gdb_byte *intermediate_buffer;

/* Compute size, source, and destination offsets for copying, in
@@ -1573,7 +1573,7 @@ write_pieced_value (struct value *to, struct value *from)
struct piece_closure *c
= (struct piece_closure *) value_computed_closure (to);
struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
- size_t type_len;
+ ULONGEST type_len;
size_t buffer_size = 0;
char *buffer = NULL;
struct cleanup *cleanup;
@@ -1589,7 +1589,7 @@ write_pieced_value (struct value *to, struct value *from)
cleanup = make_cleanup (free_current_contents, &buffer);

contents = value_contents (from);
- bits_to_skip = 8 * value_offset (to);
+ bits_to_skip = (ULONGEST)(8 * value_offset (to));
if (value_bitsize (to))
{
bits_to_skip += value_bitpos (to);
@@ -1601,8 +1601,8 @@ write_pieced_value (struct value *to, struct value *from)
for (i = 0; i < c->n_pieces && offset < type_len; i++)
{
struct dwarf_expr_piece *p = &c->pieces[i];
- size_t this_size_bits, this_size;
- long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
+ ULONGEST this_size_bits, this_size;
+ LONGEST dest_offset_bits, source_offset_bits, dest_offset, source_offset;
int need_bitwise;
const gdb_byte *source_buffer;

@@ -1731,8 +1731,8 @@ write_pieced_value (struct value *to, struct value *from)
implicit pointer. */

static int
-check_pieced_value_bits (const struct value *value, int bit_offset,
- int bit_length,
+check_pieced_value_bits (const struct value *value, LONGEST bit_offset,
+ ULONGEST bit_length,
enum dwarf_value_location check_for)
{
struct piece_closure *c
@@ -1786,8 +1786,8 @@ check_pieced_value_bits (const struct value *value, int bit_offset,
}

static int
-check_pieced_value_validity (const struct value *value, int bit_offset,
- int bit_length)
+check_pieced_value_validity (const struct value *value, LONGEST bit_offset,
+ ULONGEST bit_length)
{
return check_pieced_value_bits (value, bit_offset, bit_length,
DWARF_VALUE_MEMORY);
@@ -1805,8 +1805,8 @@ check_pieced_value_invalid (const struct value *value)
a synthetic pointer. */

static int
-check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
- int bit_length)
+check_pieced_synthetic_pointer (const struct value *value, LONGEST bit_offset,
+ ULONGEST bit_length)
{
return check_pieced_value_bits (value, bit_offset, bit_length,
DWARF_VALUE_IMPLICIT_POINTER);
@@ -1831,9 +1831,10 @@ indirect_pieced_value (struct value *value)
struct type *type;
struct frame_info *frame;
struct dwarf2_locexpr_baton baton;
- int i, bit_offset, bit_length;
+ int i;
+ ULONGEST bit_length;
struct dwarf_expr_piece *piece = NULL;
- LONGEST byte_offset;
+ LONGEST byte_offset, bit_offset;

type = check_typedef (value_type (value));
if (TYPE_CODE (type) != TYPE_CODE_PTR)
@@ -2080,7 +2081,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
struct value *value = dwarf_expr_fetch (ctx, 0);
gdb_byte *contents;
const gdb_byte *val_bytes;
- size_t n = TYPE_LENGTH (value_type (value));
+ ULONGEST n = TYPE_LENGTH (value_type (value));

if (byte_offset + TYPE_LENGTH (type) > n)
invalid_synthetic_pointer ();
diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index 412fe5b..c71e366 100644
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -804,7 +804,7 @@ struct die_info
/* Blocks are a bunch of untyped bytes. */
struct dwarf_block
{
- unsigned int size;
+ ULONGEST size;

/* Valid only if SIZE is not zero. */
gdb_byte *data;
@@ -940,12 +940,12 @@ dwarf2_complex_location_expr_complaint (void)
}

static void
-dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
- int arg3)
+dwarf2_const_value_length_mismatch_complaint (const char *arg1, ULONGEST arg2,
+ ULONGEST arg3)
{
complaint (&symfile_complaints,
- _("const value length mismatch for '%s', got %d, expected %d"),
- arg1, arg2, arg3);
+ _("const value length mismatch for '%s', got %s, expected %s"),
+ arg1, pulongest (arg2), pulongest (arg3));
}

static void
@@ -8202,7 +8202,7 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die,
object, and then subtract off the number of bits of
the field itself. The result is the bit offset of
the LSB of the field. */
- int anonymous_size;
+ ULONGEST anonymous_size;
int bit_offset = DW_UNSND (attr);

attr = dwarf2_attr (die, DW_AT_byte_size, cu);
@@ -15314,12 +15314,12 @@ dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
case DW_FORM_block4:
case DW_FORM_block:
case DW_FORM_block1:
- fprintf_unfiltered (f, "block: size %d",
- DW_BLOCK (&die->attrs[i])->size);
+ fprintf_unfiltered (f, "block: size %s",
+ pulongest (DW_BLOCK (&die->attrs[i])->size));
break;
case DW_FORM_exprloc:
- fprintf_unfiltered (f, "expression: size %u",
- DW_BLOCK (&die->attrs[i])->size);
+ fprintf_unfiltered (f, "expression: size %s",
+ pulongest (DW_BLOCK (&die->attrs[i])->size));
break;
case DW_FORM_ref_addr:
fprintf_unfiltered (f, "ref address: ");
diff --git a/gdb/eval.c b/gdb/eval.c
index de1c4bd..91028cd 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -319,7 +319,8 @@ evaluate_struct_tuple (struct value *struct_val,
int pc = *pos;
struct value *val = NULL;
int nlabels = 0;
- int bitpos, bitsize;
+ int bitsize;
+ LONGEST bitpos;
bfd_byte *addr;

/* Skip past the labels, and count them. */
@@ -462,7 +463,7 @@ init_array_element (struct value *array, struct value *element,
enum noside noside, LONGEST low_bound, LONGEST high_bound)
{
LONGEST index;
- int element_size = TYPE_LENGTH (value_type (element));
+ ULONGEST element_size = TYPE_LENGTH (value_type (element));

if (exp->elts[*pos].opcode == BINOP_COMMA)
{
@@ -625,11 +626,11 @@ binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
/* FIXME: Also mixed integral/booleans, with result an integer. */
{
const struct builtin_type *builtin = builtin_type (gdbarch);
- unsigned int promoted_len1 = TYPE_LENGTH (type1);
- unsigned int promoted_len2 = TYPE_LENGTH (type2);
+ ULONGEST promoted_len1 = TYPE_LENGTH (type1);
+ ULONGEST promoted_len2 = TYPE_LENGTH (type2);
int is_unsigned1 = TYPE_UNSIGNED (type1);
int is_unsigned2 = TYPE_UNSIGNED (type2);
- unsigned int result_len;
+ ULONGEST result_len;
int unsigned_operation;

/* Determine type length and signedness after promotion for
@@ -796,7 +797,7 @@ evaluate_subexp_standard (struct type *expect_type,
int upper, lower;
int code;
int ix;
- long mem_offset;
+ LONGEST mem_offset;
struct type **arg_types;
int save_pos1;
struct symbol *function = NULL;
@@ -985,7 +986,7 @@ evaluate_subexp_standard (struct type *expect_type,
struct type *range_type = TYPE_INDEX_TYPE (type);
struct type *element_type = TYPE_TARGET_TYPE (type);
struct value *array = allocate_value (expect_type);
- int element_size = TYPE_LENGTH (check_typedef (element_type));
+ ULONGEST element_size = TYPE_LENGTH (check_typedef (element_type));
LONGEST low_bound, high_bound, index;

if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
@@ -1994,7 +1995,8 @@ evaluate_subexp_standard (struct type *expect_type,
{
struct type *type = value_type (arg1);
struct type *real_type;
- int full, top, using_enc;
+ int full, using_enc;
+ LONGEST top;
struct value_print_options opts;

get_user_print_options (&opts);
diff --git a/gdb/f-lang.c b/gdb/f-lang.c
index 3368d01..e3bd983 100644
--- a/gdb/f-lang.c
+++ b/gdb/f-lang.c
@@ -138,7 +138,7 @@ f_printchar (int c, struct type *type, struct ui_file *stream)

static void
f_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
- unsigned int length, const char *encoding, int force_ellipses,
+ ULONGEST length, const char *encoding, int force_ellipses,
const struct value_print_options *options)
{
const char *type_encoding = f_get_encoding (type);
diff --git a/gdb/f-lang.h b/gdb/f-lang.h
index 4aae3c5..d20a46f 100644
--- a/gdb/f-lang.h
+++ b/gdb/f-lang.h
@@ -28,7 +28,7 @@ extern void f_error (char *); /* Defined in f-exp.y */
extern void f_print_type (struct type *, const char *, struct ui_file *, int,
int);

-extern void f_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
+extern void f_val_print (struct type *, const gdb_byte *, LONGEST, CORE_ADDR,
struct ui_file *, int,
const struct value *,
const struct value_print_options *);
diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
index 62a7136..f95a771 100644
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -46,7 +46,7 @@ static void f77_create_arrayprint_offset_tbl (struct type *,
struct ui_file *);
static void f77_get_dynamic_length_of_aggregate (struct type *);

-int f77_array_offset_tbl[MAX_FORTRAN_DIMS + 1][2];
+LONGEST f77_array_offset_tbl[MAX_FORTRAN_DIMS + 1][2];

/* Array which holds offsets to be applied to get a row's elements
for a given array. Array also holds the size of each subarray. */
@@ -124,7 +124,7 @@ static void
f77_create_arrayprint_offset_tbl (struct type *type, struct ui_file *stream)
{
struct type *tmp_type;
- int eltlen;
+ ULONGEST eltlen;
int ndimen = 1;
int upper, lower;

@@ -164,7 +164,7 @@ f77_create_arrayprint_offset_tbl (struct type *type, struct ui_file *stream)
static void
f77_print_array_1 (int nss, int ndimensions, struct type *type,
const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options,
@@ -215,7 +215,7 @@ f77_print_array_1 (int nss, int ndimensions, struct type *type,

static void
f77_print_array (struct type *type, const gdb_byte *valaddr,
- int embedded_offset,
+ LONGEST embedded_offset,
CORE_ADDR address, struct ui_file *stream,
int recurse,
const struct value *val,
@@ -258,8 +258,9 @@ static const struct generic_val_print_decorations f_decorations =
function; they are identical. */

void
-f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
- CORE_ADDR address, struct ui_file *stream, int recurse,
+f_val_print (struct type *type, const gdb_byte *valaddr,
+ LONGEST embedded_offset, CORE_ADDR address,
+ struct ui_file *stream, int recurse,
const struct value *original_value,
const struct value_print_options *options)
{
@@ -371,7 +372,7 @@ f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
fprintf_filtered (stream, "( ");
for (index = 0; index < TYPE_NFIELDS (type); index++)
{
- int offset = TYPE_FIELD_BITPOS (type, index) / 8;
+ LONGEST offset = TYPE_FIELD_BITPOS (type, index) / 8;

val_print (TYPE_FIELD_TYPE (type, index), valaddr,
embedded_offset + offset,
diff --git a/gdb/findcmd.c b/gdb/findcmd.c
index 3fce269..6343a34 100644
--- a/gdb/findcmd.c
+++ b/gdb/findcmd.c
@@ -169,7 +169,7 @@ parse_find_args (char *args, ULONGEST *max_countp,
while (*s != '\0')
{
LONGEST x;
- int val_bytes;
+ ULONGEST val_bytes;

while (isspace (*s))
++s;
diff --git a/gdb/findvar.c b/gdb/findvar.c
index 9009e6f..d1d8266 100644
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -92,7 +92,7 @@ extract_unsigned_integer (const gdb_byte *addr, int len,
const unsigned char *startaddr = addr;
const unsigned char *endaddr = startaddr + len;

- if (len > (int) sizeof (ULONGEST))
+ if (len > sizeof (ULONGEST))
error (_("\
That operation is not available on integers of more than %d bytes."),
(int) sizeof (ULONGEST));
@@ -415,7 +415,7 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
struct value *v;
struct type *type = SYMBOL_TYPE (var);
CORE_ADDR addr;
- int len;
+ ULONGEST len;

/* Call check_typedef on our type to make sure that, if TYPE is
a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
@@ -613,7 +613,7 @@ default_value_from_register (struct type *type, int regnum,
struct frame_info *frame)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
struct value *value = allocate_value (type);

VALUE_LVAL (value) = lval_register;
@@ -643,10 +643,10 @@ void
read_frame_register_value (struct value *value, struct frame_info *frame)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
- int offset = 0;
- int reg_offset = value_offset (value);
+ LONGEST offset = 0;
+ LONGEST reg_offset = value_offset (value);
int regnum = VALUE_REGNUM (value);
- int len = TYPE_LENGTH (check_typedef (value_type (value)));
+ ULONGEST len = TYPE_LENGTH (check_typedef (value_type (value)));

gdb_assert (VALUE_LVAL (value) == lval_register);

@@ -661,7 +661,7 @@ read_frame_register_value (struct value *value, struct frame_info *frame)
while (len > 0)
{
struct value *regval = get_frame_register_value (frame, regnum);
- int reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset;
+ ULONGEST reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset;

/* If the register length is larger than the number of bytes
remaining to copy, then only copy the appropriate bytes. */
diff --git a/gdb/frv-tdep.c b/gdb/frv-tdep.c
index 1f2400a..e5a589d 100644
--- a/gdb/frv-tdep.c
+++ b/gdb/frv-tdep.c
@@ -1123,7 +1123,7 @@ frv_extract_return_value (struct type *type, struct regcache *regcache,
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (len <= 4)
{
@@ -1142,7 +1142,7 @@ frv_extract_return_value (struct type *type, struct regcache *regcache,
}
else
internal_error (__FILE__, __LINE__,
- _("Illegal return value length: %d"), len);
+ _("Illegal return value length: %s"), pulongest (len));
}

static CORE_ADDR
@@ -1213,7 +1213,7 @@ frv_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
char valbuf[4];
struct value *arg;
struct type *arg_type;
- int len;
+ ULONGEST len;
enum type_code typecode;
CORE_ADDR regval;
int stack_space;
@@ -1331,7 +1331,7 @@ static void
frv_store_return_value (struct type *type, struct regcache *regcache,
const gdb_byte *valbuf)
{
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (len <= 4)
{
@@ -1347,7 +1347,8 @@ frv_store_return_value (struct type *type, struct regcache *regcache,
}
else
internal_error (__FILE__, __LINE__,
- _("Don't know how to return a %d-byte value."), len);
+ _("Don't know how to return a %s-byte value."),
+ pulongest (len));
}

static enum return_value_convention
diff --git a/gdb/gdbcore.h b/gdb/gdbcore.h
index 776ce9f..9408fc1 100644
--- a/gdb/gdbcore.h
+++ b/gdb/gdbcore.h
@@ -45,11 +45,11 @@ extern void memory_error (int status, CORE_ADDR memaddr);

/* Like target_read_memory, but report an error if can't read. */

-extern void read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
+extern void read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len);

/* Like target_read_stack, but report an error if can't read. */

-extern void read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
+extern void read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len);

/* Read an integer from debugged memory, given address and number of
bytes. */
@@ -83,7 +83,8 @@ CORE_ADDR read_memory_typed_address (CORE_ADDR addr, struct type *type);
byteswapping, alignment, different sizes for host vs. target types,
etc. */

-extern void write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len);
+extern void write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
+ ULONGEST len);

/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer. */
extern void write_memory_unsigned_integer (CORE_ADDR addr, int len,
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 60b0839..b56d7f1 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -1905,7 +1905,7 @@ allocate_gnat_aux_type (struct type *type)
where init_type is called with a NULL value for NAME). */

struct type *
-init_type (enum type_code code, int length, int flags,
+init_type (enum type_code code, ULONGEST length, int flags,
char *name, struct objfile *objfile)
{
struct type *type;
@@ -2137,8 +2137,8 @@ is_public_ancestor (struct type *base, struct type *dclass)

static int
is_unique_ancestor_worker (struct type *base, struct type *dclass,
- int *offset,
- const gdb_byte *valaddr, int embedded_offset,
+ LONGEST *offset,
+ const gdb_byte *valaddr, LONGEST embedded_offset,
CORE_ADDR address, struct value *val)
{
int i, count = 0;
@@ -2149,7 +2149,7 @@ is_unique_ancestor_worker (struct type *base, struct type *dclass,
for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
{
struct type *iter;
- int this_offset;
+ LONGEST this_offset;

iter = check_typedef (TYPE_BASECLASS (dclass, i));

@@ -2190,7 +2190,7 @@ is_unique_ancestor_worker (struct type *base, struct type *dclass,
int
is_unique_ancestor (struct type *base, struct value *val)
{
- int offset = -1;
+ LONGEST offset = -1;

return is_unique_ancestor_worker (base, value_type (val), &offset,
value_contents_for_printing (val),
@@ -3083,7 +3083,7 @@ recursive_dump_type (struct type *type, int spaces)
break;
}
puts_filtered ("\n");
- printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
+ printfi_filtered (spaces, "length %s\n", pulongest (TYPE_LENGTH (type)));
if (TYPE_OBJFILE_OWNED (type))
{
printfi_filtered (spaces, "objfile ");
@@ -3203,8 +3203,8 @@ recursive_dump_type (struct type *type, int spaces)
idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
else
printfi_filtered (spaces + 2,
- "[%d] bitpos %d bitsize %d type ",
- idx, TYPE_FIELD_BITPOS (type, idx),
+ "[%d] bitpos %s bitsize %d type ",
+ idx, plongest (TYPE_FIELD_BITPOS (type, idx)),
TYPE_FIELD_BITSIZE (type, idx));
gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
printf_filtered (" name '%s' (",
@@ -3486,7 +3486,7 @@ copy_type (const struct type *type)
CODE, LENGTH, and NAME fields. */
struct type *
arch_type (struct gdbarch *gdbarch,
- enum type_code code, int length, char *name)
+ enum type_code code, ULONGEST length, char *name)
{
struct type *type;

diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 887dfdb..8c4c0de 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -514,7 +514,7 @@ struct main_type
gdbarch_bits_big_endian=0 targets, it is the bit offset to
the LSB. */

- int bitpos;
+ LONGEST bitpos;

/* Enum value. */
LONGEST enumval;
@@ -684,7 +684,7 @@ struct type
HOST_CHAR_BIT. However, this would still fail to address
machines based on a ternary or decimal representation. */

- unsigned length;
+ ULONGEST length;

/* Core type, shared by a group of qualified types. */
struct main_type *main_type;
@@ -1398,11 +1398,12 @@ extern struct type *alloc_type_copy (const struct type *);
extern struct gdbarch *get_type_arch (const struct type *);

/* Helper function to construct objfile-owned types. */
-extern struct type *init_type (enum type_code, int, int, char *,
+extern struct type *init_type (enum type_code, ULONGEST, int, char *,
struct objfile *);

/* Helper functions to construct architecture-owned types. */
-extern struct type *arch_type (struct gdbarch *, enum type_code, int, char *);
+extern struct type *arch_type (struct gdbarch *, enum type_code, ULONGEST,
+ char *);
extern struct type *arch_integer_type (struct gdbarch *, int, int, char *);
extern struct type *arch_character_type (struct gdbarch *, int, int, char *);
extern struct type *arch_boolean_type (struct gdbarch *, int, int, char *);
diff --git a/gdb/gnu-v2-abi.c b/gdb/gnu-v2-abi.c
index e635e8f..d6b7d27 100644
--- a/gdb/gnu-v2-abi.c
+++ b/gdb/gnu-v2-abi.c
@@ -85,8 +85,8 @@ gnuv2_is_operator_name (const char *name)

TYPE is the type in which F is located. */
static struct value *
-gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
- struct type * type, int offset)
+gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field *f, int j,
+ struct type *type, LONGEST offset)
{
struct value *arg1 = *arg1p;
struct type *type1 = check_typedef (value_type (arg1));
@@ -187,7 +187,8 @@ gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,

static struct type *
-gnuv2_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
+gnuv2_value_rtti_type (struct value *v, int *full, LONGEST *top,
+ int *using_enc)
{
struct type *known_type;
struct type *rtti_type;
@@ -342,9 +343,9 @@ vb_match (struct type *type, int index, struct type *basetype)
target). The result is the offset of the baseclass value relative
to (the address of)(ARG) + OFFSET. */

-static int
+static LONGEST
gnuv2_baseclass_offset (struct type *type, int index,
- const bfd_byte *valaddr, int embedded_offset,
+ const bfd_byte *valaddr, LONGEST embedded_offset,
CORE_ADDR address, const struct value *val)
{
struct type *basetype = TYPE_BASECLASS (type, index);
@@ -362,8 +363,8 @@ gnuv2_baseclass_offset (struct type *type, int index,
if (vb_match (type, i, basetype))
{
struct type *field_type;
- int field_offset;
- int field_length;
+ LONGEST field_offset;
+ ULONGEST field_length;
CORE_ADDR addr;

field_type = check_typedef (TYPE_FIELD_TYPE (type, i));
@@ -387,7 +388,7 @@ gnuv2_baseclass_offset (struct type *type, int index,
/* Don't go through baseclass_offset, as that wraps
exceptions, thus, inner exceptions would be wrapped more
than once. */
- int boffset =
+ LONGEST boffset =
gnuv2_baseclass_offset (type, i, valaddr,
embedded_offset, address, val);

diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index ed94b84..180d96f 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -105,7 +105,7 @@ build_gdb_vtable_type (struct gdbarch *arch)
{
struct type *t;
struct field *field_list, *field;
- int offset;
+ ULONGEST offset;

struct type *void_ptr_type
= builtin_type (arch)->builtin_data_ptr;
@@ -181,7 +181,7 @@ vtable_ptrdiff_type (struct gdbarch *gdbarch)
/* Return the offset from the start of the imaginary `struct
gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
(i.e., where objects' virtual table pointers point). */
-static int
+static LONGEST
vtable_address_point_offset (struct gdbarch *gdbarch)
{
struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
@@ -272,7 +272,7 @@ gnuv3_get_vtable (struct gdbarch *gdbarch,

static struct type *
gnuv3_rtti_type (struct value *value,
- int *full_p, int *top_p, int *using_enc_p)
+ int *full_p, LONGEST *top_p, int *using_enc_p)
{
struct gdbarch *gdbarch;
struct type *values_type = check_typedef (value_type (value));
@@ -384,7 +384,7 @@ gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
static struct value *
gnuv3_virtual_fn_field (struct value **value_p,
struct fn_field *f, int j,
- struct type *vfn_base, int offset)
+ struct type *vfn_base, LONGEST offset)
{
struct type *values_type = check_typedef (value_type (*value_p));
struct gdbarch *gdbarch;
@@ -414,16 +414,16 @@ gnuv3_virtual_fn_field (struct value **value_p,

-1 is returned on error. */

-static int
+static LONGEST
gnuv3_baseclass_offset (struct type *type, int index,
- const bfd_byte *valaddr, int embedded_offset,
+ const bfd_byte *valaddr, LONGEST embedded_offset,
CORE_ADDR address, const struct value *val)
{
struct gdbarch *gdbarch;
struct type *ptr_type;
struct value *vtable;
struct value *vbase_array;
- long int cur_base_offset, base_offset;
+ LONGEST cur_base_offset, base_offset;

/* Determine architecture. */
gdbarch = get_type_arch (type);
@@ -446,7 +446,7 @@ gnuv3_baseclass_offset (struct type *type, int index,
cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch);
if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0)
error (_("Misaligned vbase offset."));
- cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type));
+ cur_base_offset = cur_base_offset / ((LONGEST) TYPE_LENGTH (ptr_type));

vtable = gnuv3_get_vtable (gdbarch, type, address + embedded_offset);
gdb_assert (vtable != NULL);
@@ -490,7 +490,7 @@ gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset,
we're out of luck. */
for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
{
- int pos;
+ LONGEST pos;
struct type *basetype;

if (BASETYPE_VIA_VIRTUAL (domain, i))
diff --git a/gdb/go-lang.h b/gdb/go-lang.h
index 67b5d93..51a1f7a 100644
--- a/gdb/go-lang.h
+++ b/gdb/go-lang.h
@@ -80,7 +80,7 @@ extern void go_print_type (struct type *type, const char *varstring,
/* Defined in go-valprint.c. */

extern void go_val_print (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options);
diff --git a/gdb/go-valprint.c b/gdb/go-valprint.c
index 3be4927..3a465eb 100644
--- a/gdb/go-valprint.c
+++ b/gdb/go-valprint.c
@@ -83,7 +83,7 @@ print_go_string (struct type *type, const gdb_byte *valaddr,
/* Implements the la_val_print routine for language Go. */

void
-go_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
+go_val_print (struct type *type, const gdb_byte *valaddr, LONGEST embedded_offset,
CORE_ADDR address, struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options)
diff --git a/gdb/h8300-tdep.c b/gdb/h8300-tdep.c
index aa056f9..c3c8a7e 100644
--- a/gdb/h8300-tdep.c
+++ b/gdb/h8300-tdep.c
@@ -642,7 +642,7 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
int struct_return, CORE_ADDR struct_addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int stack_alloc = 0, stack_offset = 0;
+ ULONGEST stack_alloc = 0, stack_offset = 0;
int wordsize = BINWORD (gdbarch);
int reg = E_ARG0_REGNUM;
int argument;
@@ -668,11 +668,11 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
for (argument = 0; argument < nargs; argument++)
{
struct type *type = value_type (args[argument]);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
char *contents = (char *) value_contents (args[argument]);

/* Pad the argument appropriately. */
- int padded_len = align_up (len, wordsize);
+ ULONGEST padded_len = align_up (len, wordsize);
gdb_byte *padded = alloca (padded_len);

memset (padded, 0, padded_len);
@@ -700,7 +700,7 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
/* Heavens to Betsy --- it's really going in registers!
Note that on the h8/300s, there are gaps between the
registers in the register file. */
- int offset;
+ ULONGEST offset;

for (offset = 0; offset < padded_len; offset += wordsize)
{
diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
index 7f7fb8e..585da78 100644
--- a/gdb/hppa-tdep.c
+++ b/gdb/hppa-tdep.c
@@ -963,7 +963,7 @@ hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
{
struct value *arg = args[i];
struct type *type = value_type (arg);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
const bfd_byte *valbuf;
bfd_byte fptrbuf[8];
int regnum;
@@ -1158,7 +1158,7 @@ hppa64_return_value (struct gdbarch *gdbarch, struct type *func_type,
struct type *type, struct regcache *regcache,
gdb_byte *readbuf, const gdb_byte *writebuf)
{
- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);
int regnum, offset;

if (len > 16)
diff --git a/gdb/i386-darwin-tdep.c b/gdb/i386-darwin-tdep.c
index c353154..40a772b 100644
--- a/gdb/i386-darwin-tdep.c
+++ b/gdb/i386-darwin-tdep.c
@@ -119,7 +119,7 @@ i386_m128_p (struct type *type)

/* Return the alignment for TYPE when passed as an argument. */

-static int
+static ULONGEST
i386_darwin_arg_type_alignment (struct type *type)
{
type = check_typedef (type);
@@ -139,7 +139,7 @@ i386_darwin_arg_type_alignment (struct type *type)
|| TYPE_CODE (type) == TYPE_CODE_UNION)
{
int i;
- int res = 4;
+ ULONGEST res = 4;
for (i = 0; i < TYPE_NFIELDS (type); i++)
res = max (res,
i386_darwin_arg_type_alignment (TYPE_FIELD_TYPE (type, i)));
@@ -166,7 +166,7 @@ i386_darwin_push_dummy_call (struct gdbarch *gdbarch, struct value *function,

for (write_pass = 0; write_pass < 2; write_pass++)
{
- int args_space = 0;
+ ULONGEST args_space = 0;
int num_m128 = 0;

if (struct_return)
@@ -196,8 +196,8 @@ i386_darwin_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
}
else
{
- int len = TYPE_LENGTH (arg_type);
- int align = i386_darwin_arg_type_alignment (arg_type);
+ ULONGEST len = TYPE_LENGTH (arg_type);
+ ULONGEST align = i386_darwin_arg_type_alignment (arg_type);

args_space = align_up (args_space, align);
if (write_pass)
diff --git a/gdb/i386-nat.c b/gdb/i386-nat.c
index 753de67..0ba1ed2 100644
--- a/gdb/i386-nat.c
+++ b/gdb/i386-nat.c
@@ -293,7 +293,7 @@ static int i386_remove_aligned_watchpoint (struct i386_debug_reg_state *state,
valid value, bombs through internal_error. */
static int i386_handle_nonaligned_watchpoint (struct i386_debug_reg_state *state,
i386_wp_op_t what,
- CORE_ADDR addr, int len,
+ CORE_ADDR addr, ULONGEST len,
enum target_hw_bp_type type);

/* Implementation. */
@@ -505,8 +505,8 @@ i386_remove_aligned_watchpoint (struct i386_debug_reg_state *state,

static int
i386_handle_nonaligned_watchpoint (struct i386_debug_reg_state *state,
- i386_wp_op_t what, CORE_ADDR addr, int len,
- enum target_hw_bp_type type)
+ i386_wp_op_t what, CORE_ADDR addr,
+ ULONGEST len, enum target_hw_bp_type type)
{
int retval = 0;
int max_wp_len = TARGET_HAS_DR_LEN_8 ? 8 : 4;
@@ -663,7 +663,7 @@ i386_remove_watchpoint (CORE_ADDR addr, int len, int type,
address ADDR and whose length is LEN bytes. */

static int
-i386_region_ok_for_watchpoint (CORE_ADDR addr, int len)
+i386_region_ok_for_watchpoint (CORE_ADDR addr, LONGEST len)
{
struct i386_debug_reg_state *state = i386_debug_reg_state ();
int nregs;
diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index 6858b5a..1d53bf1 100644
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -2343,7 +2343,7 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
gdb_byte buf[4];
int i;
int write_pass;
- int args_space = 0;
+ ULONGEST args_space = 0;

/* Determine the total space required for arguments and struct
return address in a first pass (allowing for 16-byte-aligned
@@ -2351,7 +2351,7 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,

for (write_pass = 0; write_pass < 2; write_pass++)
{
- int args_space_used = 0;
+ ULONGEST args_space_used = 0;
int have_16_byte_aligned_arg = 0;

if (struct_return)
@@ -2369,7 +2369,7 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,

for (i = 0; i < nargs; i++)
{
- int len = TYPE_LENGTH (value_enclosing_type (args[i]));
+ ULONGEST len = TYPE_LENGTH (value_enclosing_type (args[i]));

if (write_pass)
{
@@ -2444,7 +2444,7 @@ i386_extract_return_value (struct gdbarch *gdbarch, struct type *type,
struct regcache *regcache, gdb_byte *valbuf)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
gdb_byte buf[I386_MAX_REGISTER_SIZE];

if (TYPE_CODE (type) == TYPE_CODE_FLT)
@@ -2482,8 +2482,8 @@ i386_extract_return_value (struct gdbarch *gdbarch, struct type *type,
}
else
internal_error (__FILE__, __LINE__,
- _("Cannot extract return value of %d bytes long."),
- len);
+ _("Cannot extract return value of %s bytes long."),
+ pulongest (len));
}
}

@@ -2495,7 +2495,7 @@ i386_store_return_value (struct gdbarch *gdbarch, struct type *type,
struct regcache *regcache, const gdb_byte *valbuf)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (TYPE_CODE (type) == TYPE_CODE_FLT)
{
@@ -2547,7 +2547,8 @@ i386_store_return_value (struct gdbarch *gdbarch, struct type *type,
}
else
internal_error (__FILE__, __LINE__,
- _("Cannot store return value of %d bytes long."), len);
+ _("Cannot store return value of %s bytes long."),
+ pulongest (len));
}
}
\f
diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c
index 460345b..e29f97e 100644
--- a/gdb/ia64-tdep.c
+++ b/gdb/ia64-tdep.c
@@ -3269,7 +3269,7 @@ ia64_extract_return_value (struct type *type, struct regcache *regcache,
int offset = 0;
int regnum = IA64_GR8_REGNUM;
int reglen = TYPE_LENGTH (register_type (gdbarch, IA64_GR8_REGNUM));
- int n = TYPE_LENGTH (type) / reglen;
+ ULONGEST n = TYPE_LENGTH (type) / reglen;
int m = TYPE_LENGTH (type) % reglen;

while (n-- > 0)
@@ -3319,7 +3319,7 @@ ia64_store_return_value (struct type *type, struct regcache *regcache,
int offset = 0;
int regnum = IA64_GR8_REGNUM;
int reglen = TYPE_LENGTH (register_type (gdbarch, IA64_GR8_REGNUM));
- int n = TYPE_LENGTH (type) / reglen;
+ ULONGEST n = TYPE_LENGTH (type) / reglen;
int m = TYPE_LENGTH (type) % reglen;

while (n-- > 0)
@@ -3725,8 +3725,10 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
int argno;
struct value *arg;
struct type *type;
- int len, argoffset;
- int nslots, rseslots, memslots, slotnum, nfuncargs;
+ ULONGEST argoffset;
+ ULONGEST len;
+ int rseslots, slotnum, nfuncargs;
+ ULONGEST nslots, memslots;
int floatreg;
ULONGEST bsp;
CORE_ADDR funcdescaddr, pc, global_pointer;
diff --git a/gdb/infcall.c b/gdb/infcall.c
index 8737c7b..cfc53a7 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -710,7 +710,7 @@ call_function_by_hand (struct value *function, int nargs, struct value **args)

if (struct_return || lang_struct_return)
{
- int len = TYPE_LENGTH (values_type);
+ ULONGEST len = TYPE_LENGTH (values_type);

if (gdbarch_inner_than (gdbarch, 1, 2))
{
diff --git a/gdb/infrun.c b/gdb/infrun.c
index ab51806..360a9b7 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -6710,7 +6710,7 @@ save_infcall_suspend_state (void)
if (gdbarch_get_siginfo_type_p (gdbarch))
{
struct type *type = gdbarch_get_siginfo_type (gdbarch);
- size_t len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
struct cleanup *back_to;

siginfo_data = xmalloc (len);
@@ -6767,11 +6767,10 @@ restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
if (inf_state->siginfo_gdbarch == gdbarch)
{
struct type *type = gdbarch_get_siginfo_type (gdbarch);
- size_t len = TYPE_LENGTH (type);

/* Errors ignored. */
target_write (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
- inf_state->siginfo_data, 0, len);
+ inf_state->siginfo_data, 0, TYPE_LENGTH (type));
}

/* The inferior can be gone if the user types "print exit(0)"
diff --git a/gdb/iq2000-tdep.c b/gdb/iq2000-tdep.c
index dd8ad61..a43cf65 100644
--- a/gdb/iq2000-tdep.c
+++ b/gdb/iq2000-tdep.c
@@ -504,7 +504,7 @@ static void
iq2000_store_return_value (struct type *type, struct regcache *regcache,
const void *valbuf)
{
- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);
int regno = E_FN_RETURN_REGNUM;

while (len > 0)
@@ -550,7 +550,7 @@ iq2000_extract_return_value (struct type *type, struct regcache *regcache,
returned in a register, and if larger than 8 bytes, it is
returned in a stack location which is pointed to by the same
register. */
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (len <= (2 * 4))
{
@@ -578,7 +578,7 @@ iq2000_extract_return_value (struct type *type, struct regcache *regcache,
ULONGEST return_buffer;
regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
&return_buffer);
- read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
+ read_memory (return_buffer, valbuf, len);
}
}

@@ -655,8 +655,9 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
const bfd_byte *val;
bfd_byte buf[4];
struct type *type;
- int i, argreg, typelen, slacklen;
- int stackspace = 0;
+ int i, argreg, slacklen;
+ ULONGEST typelen;
+ ULONGEST stackspace = 0;
/* Used to copy struct arguments into the stack. */
CORE_ADDR struct_ptr;

diff --git a/gdb/jv-lang.c b/gdb/jv-lang.c
index c3c5298..58ed339 100644
--- a/gdb/jv-lang.c
+++ b/gdb/jv-lang.c
@@ -438,7 +438,7 @@ java_link_class_type (struct gdbarch *gdbarch,
for (i = TYPE_N_BASECLASSES (type); i < nfields; i++)
{
int accflags;
- int boffset;
+ LONGEST boffset;

if (fields == NULL)
{
@@ -887,7 +887,7 @@ java_printchar (int c, struct type *type, struct ui_file *stream)
static void
java_printstr (struct ui_file *stream, struct type *type,
const gdb_byte *string,
- unsigned int length, const char *encoding, int force_ellipses,
+ ULONGEST length, const char *encoding, int force_ellipses,
const struct value_print_options *options)
{
const char *type_encoding = java_get_encoding (type);
diff --git a/gdb/jv-lang.h b/gdb/jv-lang.h
index 8ea9c3c..bf77ccf 100644
--- a/gdb/jv-lang.h
+++ b/gdb/jv-lang.h
@@ -42,8 +42,8 @@ struct builtin_java_type

extern const struct builtin_java_type *builtin_java_type (struct gdbarch *);

-extern void java_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
- struct ui_file *, int,
+extern void java_val_print (struct type *, const gdb_byte *, LONGEST,
+ CORE_ADDR, struct ui_file *, int,
const struct value *,
const struct value_print_options *);

diff --git a/gdb/jv-valprint.c b/gdb/jv-valprint.c
index 12a960f..35a55b8 100644
--- a/gdb/jv-valprint.c
+++ b/gdb/jv-valprint.c
@@ -264,7 +264,7 @@ java_value_print (struct value *val, struct ui_file *stream,

static void
java_print_value_fields (struct type *type, const gdb_byte *valaddr,
- int offset,
+ LONGEST offset,
CORE_ADDR address, struct ui_file *stream,
int recurse,
const struct value *val,
@@ -482,7 +482,7 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr,

void
java_val_print (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options)
diff --git a/gdb/language.c b/gdb/language.c
index f0a8697..9ae020e 100644
--- a/gdb/language.c
+++ b/gdb/language.c
@@ -831,7 +831,7 @@ unk_lang_printchar (int c, struct type *type, struct ui_file *stream)

static void
unk_lang_printstr (struct ui_file *stream, struct type *type,
- const gdb_byte *string, unsigned int length,
+ const gdb_byte *string, ULONGEST length,
const char *encoding, int force_ellipses,
const struct value_print_options *options)
{
@@ -849,7 +849,7 @@ unk_lang_print_type (struct type *type, const char *varstring,

static void
unk_lang_val_print (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options)
diff --git a/gdb/language.h b/gdb/language.h
index d612c70..c571b81 100644
--- a/gdb/language.h
+++ b/gdb/language.h
@@ -200,7 +200,7 @@ struct language_defn
struct ui_file * stream);

void (*la_printstr) (struct ui_file * stream, struct type *elttype,
- const gdb_byte *string, unsigned int length,
+ const gdb_byte *string, ULONGEST length,
const char *encoding, int force_ellipses,
const struct value_print_options *);

@@ -242,7 +242,7 @@ struct language_defn

void (*la_val_print) (struct type *type,
const gdb_byte *contents,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options);
diff --git a/gdb/lm32-tdep.c b/gdb/lm32-tdep.c
index 4f67542..80df079 100644
--- a/gdb/lm32-tdep.c
+++ b/gdb/lm32-tdep.c
@@ -262,7 +262,7 @@ lm32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
struct value *arg = args[i];
struct type *arg_type = check_typedef (value_type (arg));
gdb_byte *contents;
- int len;
+ ULONGEST len;
int j;
int reg;
ULONGEST val;
@@ -354,7 +354,7 @@ lm32_store_return_value (struct type *type, struct regcache *regcache,
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST val;
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (len <= 4)
{
diff --git a/gdb/m2-lang.c b/gdb/m2-lang.c
index 8faa6c1..0c9d394 100644
--- a/gdb/m2-lang.c
+++ b/gdb/m2-lang.c
@@ -104,7 +104,7 @@ m2_printchar (int c, struct type *type, struct ui_file *stream)

static void
m2_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
- unsigned int length, const char *encoding, int force_ellipses,
+ ULONGEST length, const char *encoding, int force_ellipses,
const struct value_print_options *options)
{
unsigned int i;
diff --git a/gdb/m2-lang.h b/gdb/m2-lang.h
index fc6de34..9d65366 100644
--- a/gdb/m2-lang.h
+++ b/gdb/m2-lang.h
@@ -32,7 +32,7 @@ extern void m2_print_typedef (struct type *, struct symbol *,
extern int m2_is_long_set (struct type *type);
extern int m2_is_unbounded_array (struct type *type);

-extern void m2_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
+extern void m2_val_print (struct type *, const gdb_byte *, LONGEST, CORE_ADDR,
struct ui_file *, int,
const struct value *,
const struct value_print_options *);
diff --git a/gdb/m2-typeprint.c b/gdb/m2-typeprint.c
index fb3d49c..effe2c9 100644
--- a/gdb/m2-typeprint.c
+++ b/gdb/m2-typeprint.c
@@ -228,9 +228,11 @@ static void m2_array (struct type *type, struct ui_file *stream,
m2_print_bounds (TYPE_INDEX_TYPE (type), stream, show, -1, 1);
}
else
- fprintf_filtered (stream, "%d",
- (TYPE_LENGTH (type)
- / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
+ {
+ ULONGEST val = (TYPE_LENGTH (type)
+ / TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
+ fprintf_filtered (stream, "%s", pulongest (val));
+ }
}
fprintf_filtered (stream, "] OF ");
m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
@@ -587,7 +589,8 @@ m2_record_fields (struct type *type, struct ui_file *stream, int show,
void
m2_enum (struct type *type, struct ui_file *stream, int show, int level)
{
- int lastval, i, len;
+ LONGEST lastval;
+ int i, len;

if (show < 0)
{
diff --git a/gdb/m2-valprint.c b/gdb/m2-valprint.c
index 9e1c1ff..4d13dad 100644
--- a/gdb/m2-valprint.c
+++ b/gdb/m2-valprint.c
@@ -36,7 +36,7 @@ static int print_unpacked_pointer (struct type *type,
struct ui_file *stream);
static void
m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options,
@@ -68,7 +68,7 @@ get_long_set_bounds (struct type *type, LONGEST *low, LONGEST *high)

static void
m2_print_long_set (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream)
{
int empty_set = 1;
@@ -159,7 +159,7 @@ m2_print_long_set (struct type *type, const gdb_byte *valaddr,

static void
m2_print_unbounded_array (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value_print_options *options)
{
@@ -256,22 +256,20 @@ print_variable_at_address (struct type *type,

static void
m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options,
int len)
{
- int eltlen;
CHECK_TYPEDEF (type);

if (TYPE_LENGTH (type) > 0)
{
- eltlen = TYPE_LENGTH (type);
if (options->prettyprint_arrays)
print_spaces_filtered (2 + 2 * recurse, stream);
/* For an array of chars, print with string syntax. */
- if (eltlen == 1 &&
+ if (TYPE_LENGTH (type) == 1 &&
((TYPE_CODE (type) == TYPE_CODE_INT)
|| ((current_language->la_language == language_m2)
&& (TYPE_CODE (type) == TYPE_CODE_CHAR)))
@@ -304,16 +302,16 @@ static const struct generic_val_print_decorations m2_decorations =
function; they are identical. */

void
-m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
- CORE_ADDR address, struct ui_file *stream, int recurse,
+m2_val_print (struct type *type, const gdb_byte *valaddr,
+ LONGEST embedded_offset, CORE_ADDR address,
+ struct ui_file *stream, int recurse,
const struct value *original_value,
const struct value_print_options *options)
{
struct gdbarch *gdbarch = get_type_arch (type);
- unsigned int i = 0; /* Number of characters printed. */
- unsigned len;
+ ULONGEST i = 0; /* Number of characters printed. */
+ ULONGEST len;
struct type *elttype;
- unsigned eltlen;
LONGEST val;
CORE_ADDR addr;

@@ -324,12 +322,11 @@ m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
{
elttype = check_typedef (TYPE_TARGET_TYPE (type));
- eltlen = TYPE_LENGTH (elttype);
- len = TYPE_LENGTH (type) / eltlen;
+ len = TYPE_LENGTH (type) / TYPE_LENGTH (elttype);
if (options->prettyprint_arrays)
print_spaces_filtered (2 + 2 * recurse, stream);
/* For an array of chars, print with string syntax. */
- if (eltlen == 1 &&
+ if (TYPE_LENGTH (elttype) == 1 &&
((TYPE_CODE (elttype) == TYPE_CODE_INT)
|| ((current_language->la_language == language_m2)
&& (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
@@ -339,7 +336,7 @@ m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
elements up to it. */
if (options->stop_print_at_null)
{
- unsigned int temp_len;
+ ULONGEST temp_len;

/* Look for a NULL char. */
for (temp_len = 0;
diff --git a/gdb/m32r-tdep.c b/gdb/m32r-tdep.c
index d504eb3..50d08a9 100644
--- a/gdb/m32r-tdep.c
+++ b/gdb/m32r-tdep.c
@@ -696,7 +696,7 @@ m32r_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
CORE_ADDR regval;
gdb_byte *val;
gdb_byte valbuf[MAX_REGISTER_SIZE];
- int len;
+ ULONGEST len;
int odd_sized_struct;

/* First force sp to a 4-byte alignment. */
@@ -791,7 +791,7 @@ m32r_extract_return_value (struct type *type, struct regcache *regcache,
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
bfd_byte *valbuf = dst;
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
ULONGEST tmp;

/* By using store_unsigned_integer we avoid having to do
diff --git a/gdb/m68hc11-tdep.c b/gdb/m68hc11-tdep.c
index 1215de8..e9c3ee9 100644
--- a/gdb/m68hc11-tdep.c
+++ b/gdb/m68hc11-tdep.c
@@ -1174,7 +1174,7 @@ m68hc11_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
int first_stack_argnum;
struct type *type;
char *val;
- int len;
+ ULONGEST len;
char buf[2];

first_stack_argnum = 0;
@@ -1266,7 +1266,7 @@ static void
m68hc11_store_return_value (struct type *type, struct regcache *regcache,
const void *valbuf)
{
- int len;
+ ULONGEST len;

len = TYPE_LENGTH (type);

diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c
index ee72026..a219c72 100644
--- a/gdb/m68k-tdep.c
+++ b/gdb/m68k-tdep.c
@@ -292,7 +292,7 @@ static void
m68k_extract_return_value (struct type *type, struct regcache *regcache,
gdb_byte *valbuf)
{
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
gdb_byte buf[M68K_MAX_REGISTER_SIZE];

if (len <= 4)
@@ -308,14 +308,14 @@ m68k_extract_return_value (struct type *type, struct regcache *regcache,
}
else
internal_error (__FILE__, __LINE__,
- _("Cannot extract return value of %d bytes long."), len);
+ _("Cannot extract return value of %s bytes long."),
+ pulongest (len));
}

static void
m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache,
gdb_byte *valbuf)
{
- int len = TYPE_LENGTH (type);
gdb_byte buf[M68K_MAX_REGISTER_SIZE];
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
@@ -326,7 +326,7 @@ m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache,
regcache_raw_read (regcache, M68K_FP0_REGNUM, buf);
convert_typed_floating (buf, fpreg_type, valbuf, type);
}
- else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
+ else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4)
regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
else
m68k_extract_return_value (type, regcache, valbuf);
@@ -338,7 +338,7 @@ static void
m68k_store_return_value (struct type *type, struct regcache *regcache,
const gdb_byte *valbuf)
{
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (len <= 4)
regcache_raw_write_part (regcache, M68K_D0_REGNUM, 4 - len, len, valbuf);
@@ -350,14 +350,14 @@ m68k_store_return_value (struct type *type, struct regcache *regcache,
}
else
internal_error (__FILE__, __LINE__,
- _("Cannot store return value of %d bytes long."), len);
+ _("Cannot store return value of %s bytes long."),
+ pulongest (len));
}

static void
m68k_svr4_store_return_value (struct type *type, struct regcache *regcache,
const gdb_byte *valbuf)
{
- int len = TYPE_LENGTH (type);
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

@@ -368,7 +368,7 @@ m68k_svr4_store_return_value (struct type *type, struct regcache *regcache,
convert_typed_floating (valbuf, type, buf, fpreg_type);
regcache_raw_write (regcache, M68K_FP0_REGNUM, buf);
}
- else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
+ else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4)
{
regcache_raw_write (regcache, M68K_A0_REGNUM, valbuf);
regcache_raw_write (regcache, M68K_D0_REGNUM, valbuf);
@@ -515,9 +515,9 @@ m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
for (i = nargs - 1; i >= 0; i--)
{
struct type *value_type = value_enclosing_type (args[i]);
- int len = TYPE_LENGTH (value_type);
- int container_len = (len + 3) & ~3;
- int offset;
+ ULONGEST len = TYPE_LENGTH (value_type);
+ ULONGEST container_len = (len + 3) & ~3;
+ ULONGEST offset;

/* Non-scalars bigger than 4 bytes are left aligned, others are
right aligned. */
diff --git a/gdb/m88k-tdep.c b/gdb/m88k-tdep.c
index 1fda594..133be43 100644
--- a/gdb/m88k-tdep.c
+++ b/gdb/m88k-tdep.c
@@ -259,14 +259,14 @@ m88k_store_arguments (struct regcache *regcache, int nargs,
struct value **args, CORE_ADDR sp)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- int num_register_words = 0;
- int num_stack_words = 0;
+ ULONGEST num_register_words = 0;
+ ULONGEST num_stack_words = 0;
int i;

for (i = 0; i < nargs; i++)
{
struct type *type = value_type (args[i]);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (m88k_integral_or_pointer_p (type) && len < 4)
{
@@ -387,7 +387,7 @@ m88k_return_value (struct gdbarch *gdbarch, struct type *func_type,
struct type *type, struct regcache *regcache,
gdb_byte *readbuf, const gdb_byte *writebuf)
{
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
gdb_byte buf[8];

if (!m88k_integral_or_pointer_p (type) && !m88k_floating_p (type))
diff --git a/gdb/memrange.c b/gdb/memrange.c
index ed41b9a..a655dd5 100644
--- a/gdb/memrange.c
+++ b/gdb/memrange.c
@@ -21,8 +21,8 @@
#include "memrange.h"

int
-mem_ranges_overlap (CORE_ADDR start1, int len1,
- CORE_ADDR start2, int len2)
+mem_ranges_overlap (CORE_ADDR start1, ULONGEST len1,
+ CORE_ADDR start2, ULONGEST len2)
{
ULONGEST h, l;

diff --git a/gdb/memrange.h b/gdb/memrange.h
index 926af22..e07b962 100644
--- a/gdb/memrange.h
+++ b/gdb/memrange.h
@@ -30,7 +30,7 @@ struct mem_range
CORE_ADDR start;

/* Length of the range. */
- int length;
+ ULONGEST length;
};

typedef struct mem_range mem_range_s;
@@ -40,8 +40,8 @@ DEF_VEC_O(mem_range_s);
/* Returns true if the ranges defined by [start1, start1+len1) and
[start2, start2+len2) overlap. */

-extern int mem_ranges_overlap (CORE_ADDR start1, int len1,
- CORE_ADDR start2, int len2);
+extern int mem_ranges_overlap (CORE_ADDR start1, ULONGEST len1,
+ CORE_ADDR start2, ULONGEST len2);

/* Sort ranges by start address, then coalesce contiguous or
overlapping ranges. */
diff --git a/gdb/mep-tdep.c b/gdb/mep-tdep.c
index fea14bf..287ef25 100644
--- a/gdb/mep-tdep.c
+++ b/gdb/mep-tdep.c
@@ -2279,7 +2279,7 @@ push_large_arguments (CORE_ADDR sp, int argc, struct value **argv,

for (i = 0; i < argc; i++)
{
- unsigned arg_len = TYPE_LENGTH (value_type (argv[i]));
+ ULONGEST arg_len = TYPE_LENGTH (value_type (argv[i]));

if (arg_len > MEP_GPR_SIZE)
{
@@ -2337,7 +2337,7 @@ mep_push_dummy_call (struct gdbarch *gdbarch, struct value *function,

for (i = 0; i < argc; i++)
{
- unsigned arg_size = TYPE_LENGTH (value_type (argv[i]));
+ ULONGEST arg_size = TYPE_LENGTH (value_type (argv[i]));
ULONGEST value;

/* Arguments that fit in a GPR get expanded to fill the GPR. */
diff --git a/gdb/microblaze-tdep.c b/gdb/microblaze-tdep.c
index 3ce3d1c..b33c556 100644
--- a/gdb/microblaze-tdep.c
+++ b/gdb/microblaze-tdep.c
@@ -591,7 +591,7 @@ static void
microblaze_store_return_value (struct type *type, struct regcache *regcache,
const gdb_byte *valbuf)
{
- int len = TYPE_LENGTH (type);
+ int ULONGEST len = TYPE_LENGTH (type);
gdb_byte buf[8];

memset (buf, 0, sizeof(buf));
diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c
index 9a3c7fb..8c4440d 100644
--- a/gdb/mips-tdep.c
+++ b/gdb/mips-tdep.c
@@ -302,7 +302,7 @@ static void
mips_xfer_register (struct gdbarch *gdbarch, struct regcache *regcache,
int reg_num, int length,
enum bfd_endian endian, gdb_byte *in,
- const gdb_byte *out, int buf_offset)
+ const gdb_byte *out, LONGEST buf_offset)
{
int reg_offset = 0;

@@ -325,8 +325,8 @@ mips_xfer_register (struct gdbarch *gdbarch, struct regcache *regcache,
}
if (mips_debug)
fprintf_unfiltered (gdb_stderr,
- "xfer $%d, reg offset %d, buf offset %d, length %d, ",
- reg_num, reg_offset, buf_offset, length);
+ "xfer $%d, reg offset %d, buf offset %s, length %d, ",
+ reg_num, reg_offset, plongest (buf_offset), length);
if (mips_debug && out != NULL)
{
int i;
@@ -3078,13 +3078,13 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
gdb_byte valbuf[MAX_REGISTER_SIZE];
struct value *arg = args[argnum];
struct type *arg_type = check_typedef (value_type (arg));
- int len = TYPE_LENGTH (arg_type);
+ ULONGEST len = TYPE_LENGTH (arg_type);
enum type_code typecode = TYPE_CODE (arg_type);

if (mips_debug)
fprintf_unfiltered (gdb_stdlog,
- "mips_eabi_push_dummy_call: %d len=%d type=%d",
- argnum + 1, len, (int) typecode);
+ "mips_eabi_push_dummy_call: %d len=%s type=%d",
+ argnum + 1, pulongest (len), (int) typecode);

/* Function pointer arguments to mips16 code need to be made into
mips16 pointers. */
@@ -3369,7 +3369,7 @@ mips_eabi_return_value (struct gdbarch *gdbarch, struct type *func_type,

static int
mips_n32n64_fp_arg_chunk_p (struct gdbarch *gdbarch, struct type *arg_type,
- int offset)
+ LONGEST offset)
{
int i;

@@ -3384,7 +3384,7 @@ mips_n32n64_fp_arg_chunk_p (struct gdbarch *gdbarch, struct type *arg_type,

for (i = 0; i < TYPE_NFIELDS (arg_type); i++)
{
- int pos;
+ LONGEST pos;
struct type *field_type;

/* We're only looking at normal fields. */
@@ -3778,11 +3778,11 @@ mips_n32n64_return_value (struct gdbarch *gdbarch, struct type *func_type,
: MIPS_V0_REGNUM);
field < TYPE_NFIELDS (type); field++, regnum += 2)
{
- int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
- / TARGET_CHAR_BIT);
+ LONGEST offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
+ / TARGET_CHAR_BIT);
if (mips_debug)
- fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n",
- offset);
+ fprintf_unfiltered (gdb_stderr, "Return float struct+%s\n",
+ plongest (offset));
if (TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)) == 16)
{
/* A 16-byte long double field goes in two consecutive
@@ -3869,7 +3869,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
int argreg;
int float_argreg;
int argnum;
- int len = 0;
+ ULONGEST len = 0;
int stack_offset = 0;
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
@@ -3896,13 +3896,12 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
for (argnum = 0; argnum < nargs; argnum++)
{
struct type *arg_type = check_typedef (value_type (args[argnum]));
- int arglen = TYPE_LENGTH (arg_type);

/* Align to double-word if necessary. */
if (mips_type_needs_double_align (arg_type))
len = align_up (len, MIPS32_REGSIZE * 2);
/* Allocate space on the stack. */
- len += align_up (arglen, MIPS32_REGSIZE);
+ len += align_up (TYPE_LENGTH (arg_type), MIPS32_REGSIZE);
}
sp -= align_up (len, 16);

@@ -3935,13 +3934,13 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
const gdb_byte *val;
struct value *arg = args[argnum];
struct type *arg_type = check_typedef (value_type (arg));
- int len = TYPE_LENGTH (arg_type);
+ ULONGEST len = TYPE_LENGTH (arg_type);
enum type_code typecode = TYPE_CODE (arg_type);

if (mips_debug)
fprintf_unfiltered (gdb_stdlog,
- "mips_o32_push_dummy_call: %d len=%d type=%d",
- argnum + 1, len, (int) typecode);
+ "mips_o32_push_dummy_call: %d len=%s type=%d",
+ argnum + 1, pulongest (len), (int) typecode);

val = value_contents (arg);

@@ -4337,8 +4336,8 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
int argreg;
int float_argreg;
int argnum;
- int len = 0;
- int stack_offset = 0;
+ ULONGEST len = 0;
+ ULONGEST stack_offset = 0;
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR func_addr = find_function_addr (function, NULL);
@@ -4364,10 +4363,9 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
for (argnum = 0; argnum < nargs; argnum++)
{
struct type *arg_type = check_typedef (value_type (args[argnum]));
- int arglen = TYPE_LENGTH (arg_type);

/* Allocate space on the stack. */
- len += align_up (arglen, MIPS64_REGSIZE);
+ len += align_up (TYPE_LENGTH (arg_type), MIPS64_REGSIZE);
}
sp -= align_up (len, 16);

@@ -4401,13 +4399,13 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
gdb_byte valbuf[MAX_REGISTER_SIZE];
struct value *arg = args[argnum];
struct type *arg_type = check_typedef (value_type (arg));
- int len = TYPE_LENGTH (arg_type);
+ ULONGEST len = TYPE_LENGTH (arg_type);
enum type_code typecode = TYPE_CODE (arg_type);

if (mips_debug)
fprintf_unfiltered (gdb_stdlog,
- "mips_o64_push_dummy_call: %d len=%d type=%d",
- argnum + 1, len, (int) typecode);
+ "mips_o64_push_dummy_call: %d len=%s type=%d",
+ argnum + 1, pulongest (len), (int) typecode);

val = value_contents (arg);

diff --git a/gdb/mn10300-tdep.c b/gdb/mn10300-tdep.c
index 116a03e..ee68407 100644
--- a/gdb/mn10300-tdep.c
+++ b/gdb/mn10300-tdep.c
@@ -83,10 +83,11 @@ struct mn10300_prologue

/* Compute the alignment required by a type. */

-static int
+static ULONGEST
mn10300_type_align (struct type *type)
{
- int i, align = 1;
+ int i;
+ ULONGEST align = 1;

switch (TYPE_CODE (type))
{
@@ -108,7 +109,7 @@ mn10300_type_align (struct type *type)
case TYPE_CODE_UNION:
for (i = 0; i < TYPE_NFIELDS (type); i++)
{
- int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
+ ULONGEST falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
while (align < falign)
align <<= 1;
}
@@ -1228,7 +1229,7 @@ mn10300_push_dummy_call (struct gdbarch *gdbarch,
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
const int push_size = register_size (gdbarch, E_PC_REGNUM);
int regs_used;
- int len, arg_len;
+ ULONGEST len, arg_len;
int stack_offset = 0;
int argnum;
char *val, valbuf[MAX_REGISTER_SIZE];
diff --git a/gdb/moxie-tdep.c b/gdb/moxie-tdep.c
index 1f5f33f..43e2e69 100644
--- a/gdb/moxie-tdep.c
+++ b/gdb/moxie-tdep.c
@@ -124,7 +124,7 @@ moxie_store_return_value (struct type *type, struct regcache *regcache,
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR regval;
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

/* Things always get returned in RET1_REGNUM, RET2_REGNUM. */
regval = extract_unsigned_integer (valbuf, len > 4 ? 4 : len, byte_order);
@@ -321,7 +321,7 @@ moxie_extract_return_value (struct type *type, struct regcache *regcache,
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
bfd_byte *valbuf = dst;
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
ULONGEST tmp;

/* By using store_unsigned_integer we avoid having to do
diff --git a/gdb/mt-tdep.c b/gdb/mt-tdep.c
index 268be86..fa277f4 100644
--- a/gdb/mt-tdep.c
+++ b/gdb/mt-tdep.c
@@ -783,9 +783,9 @@ mt_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
gdb_byte buf[MT_MAX_STRUCT_SIZE];
int argreg = MT_1ST_ARGREG;
int split_param_len = 0;
- int stack_dest = sp;
+ ULONGEST stack_dest = sp;
int slacklen;
- int typelen;
+ ULONGEST typelen;
int i, j;

/* First handle however many args we can fit into MT_1ST_ARGREG thru
diff --git a/gdb/objc-lang.c b/gdb/objc-lang.c
index 15bf792..f0462f8 100644
--- a/gdb/objc-lang.c
+++ b/gdb/objc-lang.c
@@ -347,7 +347,7 @@ objc_printchar (int c, struct type *type, struct ui_file *stream)

static void
objc_printstr (struct ui_file *stream, struct type *type,
- const gdb_byte *string, unsigned int length,
+ const gdb_byte *string, ULONGEST length,
const char *encoding, int force_ellipses,
const struct value_print_options *options)
{
diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c
index 54075a4..ef74f48 100644
--- a/gdb/opencl-lang.c
+++ b/gdb/opencl-lang.c
@@ -80,11 +80,11 @@ builtin_opencl_type (struct gdbarch *gdbarch)

static struct type *
lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code,
- unsigned int el_length, unsigned int flag_unsigned,
+ ULONGEST el_length, unsigned int flag_unsigned,
int n)
{
int i;
- unsigned int length;
+ ULONGEST length;
struct type *type = NULL;
struct type **types = builtin_opencl_type (gdbarch);

@@ -174,9 +174,9 @@ lval_func_read (struct value *v)
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
struct type *type = check_typedef (value_type (v));
struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
- int offset = value_offset (v);
- int elsize = TYPE_LENGTH (eltype);
- int n, i, j = 0;
+ LONGEST offset = value_offset (v);
+ ULONGEST elsize = TYPE_LENGTH (eltype);
+ LONGEST n, i, j = 0;
LONGEST lowb = 0;
LONGEST highb = 0;

@@ -203,9 +203,9 @@ lval_func_write (struct value *v, struct value *fromval)
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
struct type *type = check_typedef (value_type (v));
struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
- int offset = value_offset (v);
- int elsize = TYPE_LENGTH (eltype);
- int n, i, j = 0;
+ LONGEST offset = value_offset (v);
+ ULONGEST elsize = TYPE_LENGTH (eltype);
+ LONGEST n, i, j = 0;
LONGEST lowb = 0;
LONGEST highb = 0;

@@ -243,17 +243,18 @@ lval_func_write (struct value *v, struct value *fromval)
/* Return nonzero if all bits in V within OFFSET and LENGTH are valid. */

static int
-lval_func_check_validity (const struct value *v, int offset, int length)
+lval_func_check_validity (const struct value *v, LONGEST offset,
+ ULONGEST length)
{
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
/* Size of the target type in bits. */
- int elsize =
- TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
+ ULONGEST elsize =
+ TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
int startrest = offset % elsize;
- int start = offset / elsize;
+ LONGEST start = offset / elsize;
int endrest = (offset + length) % elsize;
- int end = (offset + length) / elsize;
- int i;
+ LONGEST end = (offset + length) / elsize;
+ LONGEST i;

if (endrest)
end++;
@@ -281,8 +282,8 @@ lval_func_check_any_valid (const struct value *v)
{
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
/* Size of the target type in bits. */
- int elsize =
- TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
+ ULONGEST elsize =
+ TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
int i;

for (i = 0; i < c->n; i++)
@@ -297,17 +298,17 @@ lval_func_check_any_valid (const struct value *v)

static int
lval_func_check_synthetic_pointer (const struct value *v,
- int offset, int length)
+ LONGEST offset, ULONGEST length)
{
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
/* Size of the target type in bits. */
- int elsize =
- TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
+ ULONGEST elsize =
+ TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
int startrest = offset % elsize;
- int start = offset / elsize;
+ LONGEST start = offset / elsize;
int endrest = (offset + length) % elsize;
- int end = (offset + length) / elsize;
- int i;
+ LONGEST end = (offset + length) / elsize;
+ LONGEST i;

if (endrest)
end++;
diff --git a/gdb/p-lang.c b/gdb/p-lang.c
index c59ba0b..94f4ad6 100644
--- a/gdb/p-lang.c
+++ b/gdb/p-lang.c
@@ -96,8 +96,8 @@ pascal_main_name (void)
are not multiple of TARGET_CHAR_BIT then the results are wrong
but this does not happen for Free Pascal nor for GPC. */
int
-is_pascal_string_type (struct type *type,int *length_pos,
- int *length_size, int *string_pos,
+is_pascal_string_type (struct type *type, LONGEST *length_pos,
+ ULONGEST *length_size, LONGEST *string_pos,
struct type **char_type,
const char **arrayname)
{
@@ -217,7 +217,7 @@ pascal_printchar (int c, struct type *type, struct ui_file *stream)

void
pascal_printstr (struct ui_file *stream, struct type *type,
- const gdb_byte *string, unsigned int length,
+ const gdb_byte *string, ULONGEST length,
const char *encoding, int force_ellipses,
const struct value_print_options *options)
{
diff --git a/gdb/p-lang.h b/gdb/p-lang.h
index b1e218c..32abab2 100644
--- a/gdb/p-lang.h
+++ b/gdb/p-lang.h
@@ -35,7 +35,7 @@ extern void pascal_print_type (struct type *, const char *, struct ui_file *,
extern void pascal_print_typedef (struct type *, struct symbol *,
struct ui_file *);

-extern void pascal_val_print (struct type *, const gdb_byte *, int,
+extern void pascal_val_print (struct type *, const gdb_byte *, LONGEST,
CORE_ADDR, struct ui_file *, int,
const struct value *,
const struct value_print_options *);
@@ -49,13 +49,13 @@ extern void pascal_type_print_method_args (const char *, const char *,
/* These are in p-lang.c: */

extern int
- is_pascal_string_type (struct type *, int *, int *, int *,
+ is_pascal_string_type (struct type *, LONGEST *, ULONGEST *, LONGEST *,
struct type **, const char **);

extern void pascal_printchar (int, struct type *, struct ui_file *);

extern void pascal_printstr (struct ui_file *, struct type *, const gdb_byte *,
- unsigned int, const char *, int,
+ ULONGEST, const char *, int,
const struct value_print_options *);

extern struct type **const (pascal_builtin_types[]);
@@ -69,7 +69,7 @@ extern void
pascal_type_print_varspec_prefix (struct type *, struct ui_file *, int, int);

extern void pascal_object_print_value_fields (struct type *, const gdb_byte *,
- int,
+ LONGEST,
CORE_ADDR, struct ui_file *,
int,
const struct value *,
diff --git a/gdb/p-typeprint.c b/gdb/p-typeprint.c
index a00f5b3..828b0ce 100644
--- a/gdb/p-typeprint.c
+++ b/gdb/p-typeprint.c
@@ -442,7 +442,7 @@ pascal_type_print_base (struct type *type, struct ui_file *stream, int show,
{
int i;
int len;
- int lastval;
+ LONGEST lastval;
enum
{
s_none, s_public, s_private, s_protected
diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c
index d6373ae..807f396 100644
--- a/gdb/p-valprint.c
+++ b/gdb/p-valprint.c
@@ -58,7 +58,7 @@ static const struct generic_val_print_decorations p_decorations =

void
pascal_val_print (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *original_value,
const struct value_print_options *options)
@@ -69,8 +69,9 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
unsigned len;
LONGEST low_bound, high_bound;
struct type *elttype;
- unsigned eltlen;
- int length_pos, length_size, string_pos;
+ ULONGEST eltlen;
+ LONGEST length_pos, string_pos;
+ ULONGEST length_size;
struct type *char_type;
LONGEST val;
CORE_ADDR addr;
@@ -464,7 +465,7 @@ static void pascal_object_print_static_field (struct value *,
const struct value_print_options *);

static void pascal_object_print_value (struct type *, const gdb_byte *,
- int,
+ LONGEST,
CORE_ADDR, struct ui_file *, int,
const struct value *,
const struct value_print_options *,
@@ -523,7 +524,7 @@ pascal_object_is_vtbl_member (struct type *type)

void
pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
- int offset,
+ LONGEST offset,
CORE_ADDR address, struct ui_file *stream,
int recurse,
const struct value *val,
@@ -718,7 +719,7 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,

static void
pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
- int offset,
+ LONGEST offset,
CORE_ADDR address, struct ui_file *stream,
int recurse,
const struct value *val,
@@ -741,11 +742,11 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr,

for (i = 0; i < n_baseclasses; i++)
{
- int boffset = 0;
+ LONGEST boffset = 0;
struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
const char *basename = type_name_no_tag (baseclass);
const gdb_byte *base_valaddr = NULL;
- int thisoffset;
+ LONGEST thisoffset;
volatile struct gdb_exception ex;
int skip = 0;

diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c
index 9bd11fd..ca58089 100644
--- a/gdb/ppc-linux-nat.c
+++ b/gdb/ppc-linux-nat.c
@@ -1927,7 +1927,7 @@ num_memory_accesses (struct value *v)
of the constant. */
static int
check_condition (CORE_ADDR watch_addr, struct expression *cond,
- CORE_ADDR *data_value, int *len)
+ CORE_ADDR *data_value, ULONGEST *len)
{
int pc = 1, num_accesses_left, num_accesses_right;
struct value *left_val, *right_val, *left_chain, *right_chain;
diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c
index 20598d0..8623c14 100644
--- a/gdb/ppc-sysv-tdep.c
+++ b/gdb/ppc-sysv-tdep.c
@@ -100,9 +100,9 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
/* Next available vector register for vector arguments. */
int vreg = 2;
/* Arguments start above the "LR save word" and "Back chain". */
- int argoffset = 2 * tdep->wordsize;
+ ULONGEST argoffset = 2 * tdep->wordsize;
/* Structures start after the arguments. */
- int structoffset = argoffset + argspace;
+ ULONGEST structoffset = argoffset + argspace;

/* If the function is returning a `struct', then the first word
(which will be passed in r3) is used for struct return
@@ -121,7 +121,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
{
struct value *arg = args[argno];
struct type *type = check_typedef (value_type (arg));
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
const bfd_byte *val = value_contents (arg);

if (TYPE_CODE (type) == TYPE_CODE_FLT && len <= 8
@@ -353,7 +353,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
/* OpenCL vectors shorter than 16 bytes are passed as if
a series of independent scalars. */
struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
- int i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
+ ULONGEST i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);

for (i = 0; i < nelt; i++)
{
@@ -841,11 +841,11 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
&& opencl_abi)
{
struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
- int i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
+ ULONGEST i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);

for (i = 0; i < nelt; i++)
{
- int offset = i * TYPE_LENGTH (eltype);
+ ULONGEST offset = i * TYPE_LENGTH (eltype);

if (TYPE_CODE (eltype) == TYPE_CODE_FLT)
{
@@ -1591,7 +1591,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch,
register. Work around this by always writing the
value to memory. Fortunately, doing this
simplifies the code. */
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
if (len < tdep->wordsize)
write_memory (gparam + tdep->wordsize - len, val, len);
else
@@ -1840,12 +1840,12 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *func_type,
&& TYPE_LENGTH (valtype) >= 16
&& opencl_abi)
{
- int n_regs = TYPE_LENGTH (valtype) / 16;
- int i;
+ ULONGEST n_regs = TYPE_LENGTH (valtype) / 16;
+ ULONGEST i;

for (i = 0; i < n_regs; i++)
{
- int offset = i * 16;
+ ULONGEST offset = i * 16;
int regnum = tdep->ppc_vr0_regnum + 2 + i;

if (writebuf != NULL)
diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index d441dfe..639bc97 100644
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -296,7 +296,7 @@ print_formatted (struct value *val, int size,
struct ui_file *stream)
{
struct type *type = check_typedef (value_type (val));
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (VALUE_LVAL (val) == lval_memory)
next_address = value_address (val) + len;
@@ -352,7 +352,7 @@ float_type_from_length (struct type *type)
{
struct gdbarch *gdbarch = get_type_arch (type);
const struct builtin_type *builtin = builtin_type (gdbarch);
- unsigned int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (len == TYPE_LENGTH (builtin->builtin_float))
type = builtin->builtin_float;
@@ -375,7 +375,7 @@ print_scalar_formatted (const void *valaddr, struct type *type,
{
struct gdbarch *gdbarch = get_type_arch (type);
LONGEST val_long = 0;
- unsigned int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

/* String printing should go through val_print_scalar_formatted. */
diff --git a/gdb/python/py-prettyprint.c b/gdb/python/py-prettyprint.c
index 86d4f2c..1ceb23b 100644
--- a/gdb/python/py-prettyprint.c
+++ b/gdb/python/py-prettyprint.c
@@ -676,7 +676,7 @@ print_children (PyObject *printer, const char *hint,

int
apply_val_pretty_printer (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options,
@@ -824,7 +824,7 @@ gdbpy_default_visualizer (PyObject *self, PyObject *args)

int
apply_val_pretty_printer (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options,
diff --git a/gdb/python/python.h b/gdb/python/python.h
index dd7066f..2a57409 100644
--- a/gdb/python/python.h
+++ b/gdb/python/python.h
@@ -31,7 +31,7 @@ void eval_python_from_control_command (struct command_line *);
void source_python_script (FILE *file, const char *filename);

int apply_val_pretty_printer (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options,
diff --git a/gdb/regcache.c b/gdb/regcache.c
index c716280..12ed8fa 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -902,7 +902,7 @@ typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,

static enum register_status
regcache_xfer_part (struct regcache *regcache, int regnum,
- int offset, int len, void *in, const void *out,
+ LONGEST offset, int len, void *in, const void *out,
enum register_status (*read) (struct regcache *regcache,
int regnum,
gdb_byte *buf),
@@ -968,7 +968,7 @@ regcache_raw_write_part (struct regcache *regcache, int regnum,

enum register_status
regcache_cooked_read_part (struct regcache *regcache, int regnum,
- int offset, int len, gdb_byte *buf)
+ LONGEST offset, int len, gdb_byte *buf)
{
struct regcache_descr *descr = regcache->descr;

@@ -979,7 +979,7 @@ regcache_cooked_read_part (struct regcache *regcache, int regnum,

void
regcache_cooked_write_part (struct regcache *regcache, int regnum,
- int offset, int len, const gdb_byte *buf)
+ LONGEST offset, int len, const gdb_byte *buf)
{
struct regcache_descr *descr = regcache->descr;

diff --git a/gdb/regcache.h b/gdb/regcache.h
index 93b4499..81ccda6 100644
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -129,10 +129,10 @@ extern void regcache_cooked_write_unsigned (struct regcache *regcache,
write style operations. */

enum register_status regcache_cooked_read_part (struct regcache *regcache,
- int regnum, int offset,
+ int regnum, LONGEST offset,
int len, gdb_byte *buf);
void regcache_cooked_write_part (struct regcache *regcache, int regnum,
- int offset, int len, const gdb_byte *buf);
+ LONGEST offset, int len, const gdb_byte *buf);

/* Special routines to read/write the PC. */

diff --git a/gdb/remote.c b/gdb/remote.c
index 68864d1..995afe7 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -6450,7 +6450,7 @@ check_binary_download (CORE_ADDR addr)

static int
remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
- const gdb_byte *myaddr, int len,
+ const gdb_byte *myaddr, LONGEST len,
char packet_format, int use_length)
{
struct remote_state *rs = get_remote_state ();
@@ -6611,7 +6611,7 @@ remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
error. Only transfer a single packet. */

static int
-remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
+remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, LONGEST len)
{
char *packet_format = 0;

@@ -8034,7 +8034,7 @@ int remote_hw_watchpoint_length_limit = -1;
int remote_hw_breakpoint_limit = -1;

static int
-remote_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
+remote_region_ok_for_hw_watchpoint (CORE_ADDR addr, LONGEST len)
{
if (remote_hw_watchpoint_length_limit == 0)
return 0;
diff --git a/gdb/rl78-tdep.c b/gdb/rl78-tdep.c
index 7a84769..a8b3f6a 100644
--- a/gdb/rl78-tdep.c
+++ b/gdb/rl78-tdep.c
@@ -1019,9 +1019,8 @@ rl78_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
for (i = nargs - 1; i >= 0; i--)
{
struct type *value_type = value_enclosing_type (args[i]);
- int len = TYPE_LENGTH (value_type);
- int container_len = (len + 1) & ~1;
- int offset;
+ ULONGEST len = TYPE_LENGTH (value_type);
+ ULONGEST container_len = (len + 1) & ~1;

sp -= container_len;
write_memory (rl78_make_data_address (sp),
diff --git a/gdb/rs6000-aix-tdep.c b/gdb/rs6000-aix-tdep.c
index 5531326..0df6483 100644
--- a/gdb/rs6000-aix-tdep.c
+++ b/gdb/rs6000-aix-tdep.c
@@ -197,7 +197,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int ii;
- int len = 0;
+ ULONGEST len = 0;
int argno; /* current argument number */
int argbytes; /* current argument byte */
gdb_byte tmp_buffer[50];
@@ -327,7 +327,7 @@ ran_out_of_registers_for_arguments:

if ((argno < nargs) || argbytes)
{
- int space = 0, jj;
+ ULONGEST space = 0, jj;

if (argbytes)
{
diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index 038a3ce..7ff02ac 100644
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -376,9 +376,9 @@ s390_value_from_register (struct type *type, int regnum,
struct frame_info *frame)
{
struct value *value = default_value_from_register (type, regnum, frame);
- int len = TYPE_LENGTH (check_typedef (type));

- if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM && len < 8)
+ if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM &&
+ TYPE_LENGTH (check_typedef (type))< 8)
set_value_offset (value, 0);

return value;
@@ -2490,8 +2490,7 @@ is_power_of_two (unsigned int n)
static int
s390_function_arg_pass_by_reference (struct type *type)
{
- unsigned length = TYPE_LENGTH (type);
- if (length > 8)
+ if (TYPE_LENGTH (type) > 8)
return 1;

return (is_struct_like (type) && !is_power_of_two (TYPE_LENGTH (type)))
@@ -2504,8 +2503,7 @@ s390_function_arg_pass_by_reference (struct type *type)
static int
s390_function_arg_float (struct type *type)
{
- unsigned length = TYPE_LENGTH (type);
- if (length > 8)
+ if (TYPE_LENGTH (type) > 8)
return 0;

return is_float_like (type);
@@ -2617,11 +2615,10 @@ s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
{
struct value *arg = args[i];
struct type *type = check_typedef (value_type (arg));
- unsigned length = TYPE_LENGTH (type);

if (s390_function_arg_pass_by_reference (type))
{
- sp -= length;
+ sp -= TYPE_LENGTH (type);
sp = align_down (sp, alignment_of (type));
copy_addr[i] = sp;
}
@@ -2670,7 +2667,7 @@ s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
{
struct value *arg = args[i];
struct type *type = check_typedef (value_type (arg));
- unsigned length = TYPE_LENGTH (type);
+ ULONGEST length = TYPE_LENGTH (type);

if (s390_function_arg_pass_by_reference (type))
{
@@ -2800,8 +2797,7 @@ s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
static enum return_value_convention
s390_return_value_convention (struct gdbarch *gdbarch, struct type *type)
{
- int length = TYPE_LENGTH (type);
- if (length > 8)
+ if (TYPE_LENGTH (type) > 8)
return RETURN_VALUE_STRUCT_CONVENTION;

switch (TYPE_CODE (type))
@@ -2825,7 +2821,7 @@ s390_return_value (struct gdbarch *gdbarch, struct type *func_type,
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int word_size = gdbarch_ptr_bit (gdbarch) / 8;
enum return_value_convention rvc;
- int length;
+ ULONGEST length;

type = check_typedef (type);
rvc = s390_return_value_convention (gdbarch, type);
diff --git a/gdb/score-tdep.c b/gdb/score-tdep.c
index 90ef610..530f876 100644
--- a/gdb/score-tdep.c
+++ b/gdb/score-tdep.c
@@ -516,7 +516,7 @@ score_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int argnum;
int argreg;
- int arglen = 0;
+ ULONGEST arglen = 0;
CORE_ADDR stack_offset = 0;
CORE_ADDR addr = 0;

diff --git a/gdb/sh-tdep.c b/gdb/sh-tdep.c
index 7f15191..73822b2 100644
--- a/gdb/sh-tdep.c
+++ b/gdb/sh-tdep.c
@@ -1308,7 +1308,7 @@ sh_extract_return_value_nofpu (struct type *type, struct regcache *regcache,
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
int return_register = R0_REGNUM;
int offset;

@@ -1362,7 +1362,7 @@ sh_store_return_value_nofpu (struct type *type, struct regcache *regcache,
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST val;
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (len <= 4)
{
diff --git a/gdb/sh64-tdep.c b/gdb/sh64-tdep.c
index 2e5d8bd..181892c 100644
--- a/gdb/sh64-tdep.c
+++ b/gdb/sh64-tdep.c
@@ -1059,7 +1059,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
CORE_ADDR struct_addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int stack_offset, stack_alloc;
+ ULONGEST stack_offset, stack_alloc;
int int_argreg;
int float_argreg;
int double_argreg;
@@ -1071,7 +1071,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
char *val;
char valbuf[8];
char valbuf_tmp[8];
- int len;
+ ULONGEST len;
int argreg_size;
int fp_args[12];

@@ -1230,7 +1230,7 @@ sh64_extract_return_value (struct type *type, struct regcache *regcache,
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (TYPE_CODE (type) == TYPE_CODE_FLT)
{
@@ -1292,7 +1292,7 @@ sh64_store_return_value (struct type *type, struct regcache *regcache,
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
char buf[64]; /* more than enough... */
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (TYPE_CODE (type) == TYPE_CODE_FLT)
{
diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c
index 00bca01..fb363d5 100644
--- a/gdb/sparc-tdep.c
+++ b/gdb/sparc-tdep.c
@@ -470,7 +470,7 @@ sparc32_store_arguments (struct regcache *regcache, int nargs,
for (i = 0; i < nargs; i++)
{
struct type *type = value_type (args[i]);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (sparc_structure_or_union_p (type)
|| (sparc_floating_p (type) && len == 16)
diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c
index f30022e..a9a2935 100644
--- a/gdb/sparc64-tdep.c
+++ b/gdb/sparc64-tdep.c
@@ -639,7 +639,8 @@ sparc64_16_byte_align_p (struct type *type)

static void
sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
- const gdb_byte *valbuf, int element, int bitpos)
+ const gdb_byte *valbuf, int element,
+ LONGEST bitpos)
{
int len = TYPE_LENGTH (type);

@@ -681,7 +682,7 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
for (i = 0; i < TYPE_NFIELDS (type); i++)
{
struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
- int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
+ LONGEST subpos = bitpos + TYPE_FIELD_BITPOS (type, i);

sparc64_store_floating_fields (regcache, subtype, valbuf,
element, subpos);
@@ -713,7 +714,7 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type,

static void
sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
- gdb_byte *valbuf, int bitpos)
+ gdb_byte *valbuf, LONGEST bitpos)
{
if (sparc64_floating_p (type))
{
@@ -750,7 +751,7 @@ sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
for (i = 0; i < TYPE_NFIELDS (type); i++)
{
struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
- int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
+ LONGEST subpos = bitpos + TYPE_FIELD_BITPOS (type, i);

sparc64_extract_floating_fields (regcache, subtype, valbuf, subpos);
}
@@ -783,7 +784,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
for (i = 0; i < nargs; i++)
{
struct type *type = value_type (args[i]);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (sparc64_structure_or_union_p (type)
|| (sparc64_complex_floating_p (type) && len == 32))
diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c
index 78ba007..76db368 100644
--- a/gdb/spu-tdep.c
+++ b/gdb/spu-tdep.c
@@ -316,7 +316,7 @@ spu_value_from_register (struct type *type, int regnum,
struct frame_info *frame)
{
struct value *value = default_value_from_register (type, regnum, frame);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (regnum < SPU_NUM_GPRS && len < 16)
{
diff --git a/gdb/stack.c b/gdb/stack.c
index bbd6b7f..54e200d 100644
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -354,7 +354,7 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame,

if (val && entryval && !ui_out_is_mi_like_p (current_uiout))
{
- unsigned len = TYPE_LENGTH (value_type (val));
+ ULONGEST len = TYPE_LENGTH (value_type (val));

if (!value_optimized_out (val) && value_lazy (val))
value_fetch_lazy (val);
@@ -373,7 +373,7 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame,

TRY_CATCH (except, RETURN_MASK_ERROR)
{
- unsigned len_deref;
+ ULONGEST len_deref;

val_deref = coerce_ref (val);
if (value_lazy (val_deref))
@@ -532,8 +532,8 @@ print_frame_args (struct symbol *func, struct frame_info *frame,
case LOC_ARG:
case LOC_REF_ARG:
{
- long current_offset = SYMBOL_VALUE (sym);
- int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
+ LONGEST current_offset = SYMBOL_VALUE (sym);
+ ULONGEST arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));

/* Compute address of next argument by adding the size of
this argument and rounding to an int boundary. */
diff --git a/gdb/symfile-mem.c b/gdb/symfile-mem.c
index 91125e1..a3c15d0 100644
--- a/gdb/symfile-mem.c
+++ b/gdb/symfile-mem.c
@@ -55,6 +55,11 @@
#include "auxv.h"
#include "elf/common.h"

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

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

nbfd = bfd_elf_bfd_from_remote_memory (templ, addr, &loadbase,
- target_read_memory);
+ symfile_target_read_memory);
if (nbfd == NULL)
error (_("Failed to read a valid object file image from memory."));

diff --git a/gdb/symmisc.c b/gdb/symmisc.c
index b0ab29b..d5fdd92 100644
--- a/gdb/symmisc.c
+++ b/gdb/symmisc.c
@@ -516,11 +516,11 @@ print_symbol (void *args)

case LOC_CONST_BYTES:
{
- unsigned i;
+ ULONGEST i;
struct type *type = check_typedef (SYMBOL_TYPE (symbol));

- fprintf_filtered (outfile, "const %u hex bytes:",
- TYPE_LENGTH (type));
+ fprintf_filtered (outfile, "const %s hex bytes:",
+ pulongest (TYPE_LENGTH (type)));
for (i = 0; i < TYPE_LENGTH (type); i++)
fprintf_filtered (outfile, " %02x",
(unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
diff --git a/gdb/target.c b/gdb/target.c
index cffea2c..bc7c238 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -52,7 +52,7 @@ static void default_terminal_info (char *, int);
static int default_watchpoint_addr_within_range (struct target_ops *,
CORE_ADDR, CORE_ADDR, int);

-static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
+static int default_region_ok_for_hw_watchpoint (CORE_ADDR, LONGEST);

static void tcomplain (void) ATTRIBUTE_NORETURN;

@@ -128,7 +128,7 @@ static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
static int debug_to_watchpoint_addr_within_range (struct target_ops *,
CORE_ADDR, CORE_ADDR, int);

-static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
+static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, LONGEST);

static int debug_to_can_accel_watchpoint_condition (CORE_ADDR, int, int,
struct expression *);
@@ -1757,7 +1757,7 @@ target_xfer_partial (struct target_ops *ops,
it makes no progress, and then return how much was transferred). */

int
-target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
+target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, LONGEST len)
{
/* Dispatch to the topmost target, not the flattened current_target.
Memory accesses check target->to_has_(all_)memory, and the
@@ -1773,7 +1773,7 @@ target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
the target's stack. This may trigger different cache behavior. */

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

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

int
-target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
+target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
+ LONGEST len)
{
/* Dispatch to the topmost target, not the flattened current_target.
Memory accesses check target->to_has_(all_)memory, and the
@@ -3543,7 +3544,7 @@ target_fileio_read_stralloc (const char *filename)

static int
-default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
+default_region_ok_for_hw_watchpoint (CORE_ADDR addr, LONGEST len)
{
return (len <= gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT);
}
@@ -4217,7 +4218,7 @@ debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
}

static int
-debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
+debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, LONGEST len)
{
CORE_ADDR retval;

diff --git a/gdb/target.h b/gdb/target.h
index 50a0ea6..a76f785 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -478,7 +478,7 @@ struct target_ops

/* Documentation of this routine is provided with the corresponding
target_* macro. */
- int (*to_region_ok_for_hw_watchpoint) (CORE_ADDR, int);
+ int (*to_region_ok_for_hw_watchpoint) (CORE_ADDR, LONGEST);

int (*to_can_accel_watchpoint_condition) (CORE_ADDR, int, int,
struct expression *);
@@ -996,15 +996,17 @@ extern void target_dcache_invalidate (void);

extern int target_read_string (CORE_ADDR, char **, int, int *);

-extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
+extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
+ LONGEST len);

-extern int target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
+extern int target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr,
+ LONGEST len);

extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
- int len);
+ LONGEST len);

extern int target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
- int len);
+ LONGEST len);

/* Fetches the target's memory map. If one is found it is sorted
and returned, after some consistency checking. Otherwise, NULL
diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index 6e47a0a..42af6bc 100644
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -967,7 +967,7 @@ collect_symbol (struct collection_list *collect,
long frame_regno, long frame_offset,
CORE_ADDR scope)
{
- unsigned long len;
+ ULONGEST len;
unsigned int reg;
bfd_signed_vma offset;
int treat_as_expr = 0;
@@ -1448,7 +1448,8 @@ encode_actions_1 (struct command_line *action,
}
else
{
- unsigned long addr, len;
+ CORE_ADDR addr;
+ ULONGEST len;
struct cleanup *old_chain = NULL;
struct cleanup *old_chain1 = NULL;

@@ -2613,7 +2614,8 @@ scope_info (char *args, int from_tty)
const char *symname;
char *save_args = args;
struct dict_iterator iter;
- int j, count = 0;
+ int count = 0;
+ ULONGEST j;
struct gdbarch *gdbarch;
int regno;

@@ -2743,8 +2745,10 @@ scope_info (char *args, int from_tty)
break;
}
if (SYMBOL_TYPE (sym))
- printf_filtered (", length %d.\n",
- TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
+ {
+ ULONGEST len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
+ printf_filtered (", length %s.\n", pulongest (len));
+ }
}
if (BLOCK_FUNCTION (block))
break;
diff --git a/gdb/typeprint.c b/gdb/typeprint.c
index c25e705..4bbf8a7 100644
--- a/gdb/typeprint.c
+++ b/gdb/typeprint.c
@@ -118,7 +118,7 @@ whatis_exp (char *exp, int show)
struct type *real_type = NULL;
struct type *type;
int full = 0;
- int top = -1;
+ LONGEST top = -1;
int using_enc = 0;
struct value_print_options opts;

diff --git a/gdb/v850-tdep.c b/gdb/v850-tdep.c
index 240a154..8cbf3b3 100644
--- a/gdb/v850-tdep.c
+++ b/gdb/v850-tdep.c
@@ -810,7 +810,7 @@ v850_push_dummy_call (struct gdbarch *gdbarch,
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int argreg;
int argnum;
- int len = 0;
+ ULONGEST len = 0;
int stack_offset;

/* The offset onto the stack at which we will start copying parameters
@@ -891,7 +891,7 @@ v850_extract_return_value (struct type *type, struct regcache *regcache,
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);

if (len <= v850_reg_size)
{
@@ -918,7 +918,7 @@ v850_store_return_value (struct type *type, struct regcache *regcache,
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);

if (len <= v850_reg_size)
regcache_cooked_write_unsigned
diff --git a/gdb/valarith.c b/gdb/valarith.c
index a17c91a..16e760d 100644
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -196,8 +196,8 @@ value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound)
{
struct type *array_type = check_typedef (value_type (array));
struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
- unsigned int elt_size = TYPE_LENGTH (elt_type);
- unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
+ ULONGEST elt_size = TYPE_LENGTH (elt_type);
+ ULONGEST elt_offs = elt_size * (index - lowerbound);
struct value *v;

if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
@@ -1474,7 +1474,7 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
int
value_logical_not (struct value *arg1)
{
- int len;
+ LONGEST len;
const gdb_byte *p;
struct type *type1;

@@ -1505,8 +1505,8 @@ value_logical_not (struct value *arg1)
static int
value_strcmp (struct value *arg1, struct value *arg2)
{
- int len1 = TYPE_LENGTH (value_type (arg1));
- int len2 = TYPE_LENGTH (value_type (arg2));
+ LONGEST len1 = TYPE_LENGTH (value_type (arg1));
+ LONGEST len2 = TYPE_LENGTH (value_type (arg2));
const gdb_byte *s1 = value_contents (arg1);
const gdb_byte *s2 = value_contents (arg2);
int i, len = len1 < len2 ? len1 : len2;
diff --git a/gdb/valops.c b/gdb/valops.c
index ee450e3..5018864 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -53,11 +53,11 @@ static int typecmp (int staticp, int varargs, int nargs,
struct field t1[], struct value *t2[]);

static struct value *search_struct_field (const char *, struct value *,
- int, struct type *, int);
+ LONGEST, struct type *, int);

static struct value *search_struct_method (const char *, struct value **,
struct value **,
- int, int *, struct type *);
+ LONGEST, int *, struct type *);

static int find_oload_champ_namespace (struct value **, int,
const char *, const char *,
@@ -85,7 +85,7 @@ oload_classification classify_oload_match (struct badness_vector *,
int, int);

static struct value *value_struct_elt_for_reference (struct type *,
- int, struct type *,
+ LONGEST, struct type *,
char *,
struct type *,
int, enum noside);
@@ -102,8 +102,8 @@ static CORE_ADDR allocate_space_in_inferior (int);
static struct value *cast_into_complex (struct type *, struct value *);

static struct fn_field *find_method_list (struct value **, const char *,
- int, struct type *, int *,
- struct type **, int *);
+ LONGEST, struct type *, int *,
+ struct type **, LONGEST *);

void _initialize_valops (void);

@@ -188,14 +188,14 @@ find_function_in_inferior (const char *name, struct objfile **objf_p)
space. */

struct value *
-value_allocate_space_in_inferior (int len)
+value_allocate_space_in_inferior (ULONGEST len)
{
struct objfile *objf;
struct value *val = find_function_in_inferior ("malloc", &objf);
struct gdbarch *gdbarch = get_objfile_arch (objf);
struct value *blocklen;

- blocklen = value_from_longest (builtin_type (gdbarch)->builtin_int, len);
+ blocklen = value_from_ulongest (builtin_type (gdbarch)->builtin_int, len);
val = call_function_by_hand (val, 1, &blocklen);
if (value_logical_not (val))
{
@@ -261,7 +261,8 @@ value_cast_structs (struct type *type, struct value *v2)
if (TYPE_NAME (t2) != NULL)
{
/* Try downcasting using the run-time type of the value. */
- int full, top, using_enc;
+ int full, using_enc;
+ LONGEST top;
struct type *real_type;

real_type = value_rtti_type (v2, &full, &top, &using_enc);
@@ -396,12 +397,12 @@ value_cast (struct type *type, struct value *arg2)
if (code1 == TYPE_CODE_ARRAY)
{
struct type *element_type = TYPE_TARGET_TYPE (type);
- unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
+ ULONGEST element_length = TYPE_LENGTH (check_typedef (element_type));

if (element_length > 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
{
struct type *range_type = TYPE_INDEX_TYPE (type);
- int val_length = TYPE_LENGTH (type2);
+ ULONGEST val_length = TYPE_LENGTH (type2);
LONGEST low_bound, high_bound, new_length;

if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
@@ -651,7 +652,7 @@ value_reinterpret_cast (struct type *type, struct value *arg)
static int
dynamic_cast_check_1 (struct type *desired_type,
const gdb_byte *valaddr,
- int embedded_offset,
+ LONGEST embedded_offset,
CORE_ADDR address,
struct value *val,
struct type *search_type,
@@ -663,8 +664,8 @@ dynamic_cast_check_1 (struct type *desired_type,

for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
{
- int offset = baseclass_offset (search_type, i, valaddr, embedded_offset,
- address, val);
+ LONGEST offset = baseclass_offset (search_type, i, valaddr,
+ embedded_offset, address, val);

if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
{
@@ -698,7 +699,7 @@ dynamic_cast_check_1 (struct type *desired_type,
static int
dynamic_cast_check_2 (struct type *desired_type,
const gdb_byte *valaddr,
- int embedded_offset,
+ LONGEST embedded_offset,
CORE_ADDR address,
struct value *val,
struct type *search_type,
@@ -708,7 +709,7 @@ dynamic_cast_check_2 (struct type *desired_type,

for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
{
- int offset;
+ LONGEST offset;

if (! BASETYPE_VIA_PUBLIC (search_type, i))
continue;
@@ -739,7 +740,8 @@ dynamic_cast_check_2 (struct type *desired_type,
struct value *
value_dynamic_cast (struct type *type, struct value *arg)
{
- int full, top, using_enc;
+ int full, using_enc;
+ LONGEST top;
struct type *resolved_type = check_typedef (type);
struct type *arg_type = check_typedef (value_type (arg));
struct type *class_type, *rtti_type;
@@ -990,7 +992,7 @@ value_fetch_lazy (struct value *val)
struct value *parent = value_parent (val);
LONGEST offset = value_offset (val);
LONGEST num;
- int length = TYPE_LENGTH (type);
+ ULONGEST length = TYPE_LENGTH (type);

if (!value_bits_valid (val,
TARGET_CHAR_BIT * offset + value_bitpos (val),
@@ -1012,7 +1014,8 @@ value_fetch_lazy (struct value *val)
else if (VALUE_LVAL (val) == lval_memory)
{
CORE_ADDR addr = value_address (val);
- int length = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
+ struct type *enclosing_type = value_enclosing_type (val);
+ ULONGEST length = TYPE_LENGTH (check_typedef (enclosing_type));

if (length)
read_value_memory (val, 0, value_stack (val),
@@ -1123,7 +1126,7 @@ value_fetch_lazy (struct value *val)
void
read_value_memory (struct value *val, int embedded_offset,
int stack, CORE_ADDR memaddr,
- gdb_byte *buffer, size_t length)
+ gdb_byte *buffer, ULONGEST length)
{
if (length)
{
@@ -1256,7 +1259,7 @@ value_assign (struct value *toval, struct value *fromval)
{
const gdb_byte *dest_buffer;
CORE_ADDR changed_addr;
- int changed_len;
+ ULONGEST changed_len;
gdb_byte buffer[sizeof (LONGEST)];

if (value_bitsize (toval))
@@ -1329,7 +1332,7 @@ value_assign (struct value *toval, struct value *fromval)
if (value_bitsize (toval))
{
struct value *parent = value_parent (toval);
- int offset = value_offset (parent) + value_offset (toval);
+ LONGEST offset = value_offset (parent) + value_offset (toval);
int changed_len;
gdb_byte buffer[sizeof (LONGEST)];
int optim, unavail;
@@ -1794,7 +1797,7 @@ value_array (int lowbound, int highbound, struct value **elemvec)
{
int nelem;
int idx;
- unsigned int typelength;
+ ULONGEST typelength;
struct value *val;
struct type *arraytype;

@@ -1985,7 +1988,7 @@ typecmp (int staticp, int varargs, int nargs,
fields, look for a baseclass named NAME. */

static struct value *
-search_struct_field (const char *name, struct value *arg1, int offset,
+search_struct_field (const char *name, struct value *arg1, LONGEST offset,
struct type *type, int looking_for_baseclass)
{
int i;
@@ -2043,7 +2046,7 @@ search_struct_field (const char *name, struct value *arg1, int offset,
<variant field>. */

struct value *v;
- int new_offset = offset;
+ LONGEST new_offset = offset;

/* This is pretty gross. In G++, the offset in an
anonymous union is relative to the beginning of the
@@ -2080,7 +2083,7 @@ search_struct_field (const char *name, struct value *arg1, int offset,

if (BASETYPE_VIA_VIRTUAL (type, i))
{
- int boffset;
+ LONGEST boffset;
struct value *v2;

boffset = baseclass_offset (type, i,
@@ -2144,7 +2147,7 @@ search_struct_field (const char *name, struct value *arg1, int offset,

static struct value *
search_struct_method (const char *name, struct value **arg1p,
- struct value **args, int offset,
+ struct value **args, LONGEST offset,
int *static_memfuncp, struct type *type)
{
int i;
@@ -2208,9 +2211,9 @@ search_struct_method (const char *name, struct value **arg1p,

for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
{
- int base_offset;
+ LONGEST base_offset;
int skip = 0;
- int this_offset;
+ LONGEST this_offset;

if (BASETYPE_VIA_VIRTUAL (type, i))
{
@@ -2386,8 +2389,8 @@ value_struct_elt (struct value **argp, struct value **args,

static struct fn_field *
find_method_list (struct value **argp, const char *method,
- int offset, struct type *type, int *num_fns,
- struct type **basetype, int *boffset)
+ LONGEST offset, struct type *type, int *num_fns,
+ struct type **basetype, LONGEST *boffset)
{
int i;
struct fn_field *f;
@@ -2420,7 +2423,7 @@ find_method_list (struct value **argp, const char *method,
/* Not found in object, check in base subobjects. */
for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
{
- int base_offset;
+ LONGEST base_offset;

if (BASETYPE_VIA_VIRTUAL (type, i))
{
@@ -2456,7 +2459,7 @@ find_method_list (struct value **argp, const char *method,
struct fn_field *
value_find_oload_method_list (struct value **argp, const char *method,
int offset, int *num_fns,
- struct type **basetype, int *boffset)
+ struct type **basetype, LONGEST *boffset)
{
struct type *t;

@@ -2548,7 +2551,7 @@ find_overload_match (struct value **args, int nargs,
/* Number of overloaded instances being considered. */
int num_fns = 0;
struct type *basetype = NULL;
- int boffset;
+ LONGEST boffset;

struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL);

@@ -3255,7 +3258,7 @@ compare_parameters (struct type *t1, struct type *t2, int skip_artificial)
the form "DOMAIN::NAME". */

static struct value *
-value_struct_elt_for_reference (struct type *domain, int offset,
+value_struct_elt_for_reference (struct type *domain, LONGEST offset,
struct type *curtype, char *name,
struct type *intype,
int want_address,
@@ -3292,7 +3295,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
if (want_address)
return value_from_longest
(lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
- offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
+ offset + (TYPE_FIELD_BITPOS (t, i) >> 3));
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
return allocate_value (TYPE_FIELD_TYPE (t, i));
else
@@ -3435,7 +3438,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
{
struct value *v;
- int base_offset;
+ LONGEST base_offset;

if (BASETYPE_VIA_VIRTUAL (t, i))
base_offset = 0;
@@ -3525,7 +3528,7 @@ value_maybe_namespace_elt (const struct type *curtype,

struct type *
value_rtti_indirect_type (struct value *v, int *full,
- int *top, int *using_enc)
+ LONGEST *top, int *using_enc)
{
struct value *target;
struct type *type, *real_type, *target_type;
@@ -3575,12 +3578,12 @@ value_rtti_indirect_type (struct value *v, int *full,
struct value *
value_full_object (struct value *argp,
struct type *rtype,
- int xfull, int xtop,
+ int xfull, LONGEST xtop,
int xusing_enc)
{
struct type *real_type;
int full = 0;
- int top = -1;
+ LONGEST top = -1;
int using_enc = 0;
struct value *new_val;

diff --git a/gdb/valprint.c b/gdb/valprint.c
index 25b62bc..f5e168a 100644
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -253,7 +253,7 @@ scalar_type_p (struct type *type)
int
valprint_check_validity (struct ui_file *stream,
struct type *type,
- int embedded_offset,
+ LONGEST embedded_offset,
const struct value *val)
{
CHECK_TYPEDEF (type);
@@ -317,7 +317,7 @@ val_print_invalid_address (struct ui_file *stream)

void
generic_val_print (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *original_value,
const struct value_print_options *options,
@@ -680,7 +680,7 @@ generic_val_print (struct type *type, const gdb_byte *valaddr,
RECURSE. */

void
-val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
+val_print (struct type *type, const gdb_byte *valaddr, LONGEST embedded_offset,
CORE_ADDR address, struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options,
@@ -892,7 +892,7 @@ val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,

void
val_print_scalar_formatted (struct type *type,
- const gdb_byte *valaddr, int embedded_offset,
+ const gdb_byte *valaddr, LONGEST embedded_offset,
const struct value *val,
const struct value_print_options *options,
int size,
@@ -1433,7 +1433,7 @@ print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,

void
print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
- unsigned len, enum bfd_endian byte_order)
+ ULONGEST len, enum bfd_endian byte_order)
{
const gdb_byte *p;

@@ -1550,7 +1550,7 @@ maybe_print_array_index (struct type *index_type, LONGEST index,

void
val_print_array_elements (struct type *type,
- const gdb_byte *valaddr, int embedded_offset,
+ const gdb_byte *valaddr, LONGEST embedded_offset,
CORE_ADDR address, struct ui_file *stream,
int recurse,
const struct value *val,
@@ -1558,9 +1558,9 @@ val_print_array_elements (struct type *type,
unsigned int i)
{
unsigned int things_printed = 0;
- unsigned len;
+ ULONGEST len;
struct type *elttype, *index_type;
- unsigned eltlen;
+ ULONGEST eltlen;
/* Position of the array element we are examining to see
whether it is repeated. */
unsigned int rep1;
@@ -2046,8 +2046,8 @@ generic_emit_char (int c, struct type *type, struct ui_file *stream,
omitted. */

void
-generic_printstr (struct ui_file *stream, struct type *type,
- const gdb_byte *string, unsigned int length,
+generic_printstr (struct ui_file *stream, struct type *type,
+ const gdb_byte *string, ULONGEST length,
const char *encoding, int force_ellipses,
int quote_char, int c_style_terminator,
const struct value_print_options *options)
diff --git a/gdb/valprint.h b/gdb/valprint.h
index 56c0c92..2841929 100644
--- a/gdb/valprint.h
+++ b/gdb/valprint.h
@@ -113,7 +113,7 @@ extern void maybe_print_array_index (struct type *index_type, LONGEST index,
struct ui_file *stream,
const struct value_print_options *);

-extern void val_print_array_elements (struct type *, const gdb_byte *, int,
+extern void val_print_array_elements (struct type *, const gdb_byte *, LONGEST,
CORE_ADDR, struct ui_file *, int,
const struct value *,
const struct value_print_options *,
@@ -127,7 +127,7 @@ extern void val_print_type_code_flags (struct type *type,
struct ui_file *stream);

extern void val_print_scalar_formatted (struct type *,
- const gdb_byte *, int,
+ const gdb_byte *, LONGEST,
const struct value *,
const struct value_print_options *,
int,
@@ -143,7 +143,7 @@ extern void print_decimal_chars (struct ui_file *, const gdb_byte *,
unsigned int, enum bfd_endian);

extern void print_hex_chars (struct ui_file *, const gdb_byte *,
- unsigned int, enum bfd_endian);
+ ULONGEST, enum bfd_endian);

extern void print_char_chars (struct ui_file *, struct type *,
const gdb_byte *, unsigned int, enum bfd_endian);
@@ -187,7 +187,7 @@ struct generic_val_print_decorations

extern void generic_val_print (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *original_value,
const struct value_print_options *options,
@@ -196,8 +196,8 @@ extern void generic_val_print (struct type *type, const gdb_byte *valaddr,
extern void generic_emit_char (int c, struct type *type, struct ui_file *stream,
int quoter, const char *encoding);

-extern void generic_printstr (struct ui_file *stream, struct type *type,
- const gdb_byte *string, unsigned int length,
+extern void generic_printstr (struct ui_file *stream, struct type *type,
+ const gdb_byte *string, ULONGEST length,
const char *encoding, int force_ellipses,
int quote_char, int c_style_terminator,
const struct value_print_options *options);
diff --git a/gdb/value.c b/gdb/value.c
index d498289..30a4a42 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -67,10 +67,10 @@ struct internal_function
struct range
{
/* Lowest offset in the range. */
- int offset;
+ LONGEST offset;

/* Length of the range. */
- int length;
+ ULONGEST length;
};

typedef struct range range_s;
@@ -81,8 +81,8 @@ DEF_VEC_O(range_s);
[offset2, offset2+len2) overlap. */

static int
-ranges_overlap (int offset1, int len1,
- int offset2, int len2)
+ranges_overlap (LONGEST offset1, ULONGEST len1,
+ LONGEST offset2, ULONGEST len2)
{
ULONGEST h, l;

@@ -106,7 +106,7 @@ range_lessthan (const range_s *r1, const range_s *r2)
OFFSET+LENGTH). */

static int
-ranges_contain (VEC(range_s) *ranges, int offset, int length)
+ranges_contain (VEC(range_s) *ranges, LONGEST offset, ULONGEST length)
{
range_s what;
int i;
@@ -239,7 +239,7 @@ struct value
lval == lval_register, this is a further offset from
location.address within the registers structure. Note also the
member embedded_offset below. */
- int offset;
+ LONGEST offset;

/* Only used for bitfields; number of bits contained in them. */
int bitsize;
@@ -309,8 +309,8 @@ struct value
`type', and `embedded_offset' is zero, so everything works
normally. */
struct type *enclosing_type;
- int embedded_offset;
- int pointed_to_offset;
+ LONGEST embedded_offset;
+ LONGEST pointed_to_offset;

/* Values are stored in a chain, so that they can be deleted easily
over calls to the inferior. Values assigned to internal
@@ -332,7 +332,8 @@ struct value
};

int
-value_bytes_available (const struct value *value, int offset, int length)
+value_bytes_available (const struct value *value, LONGEST offset,
+ ULONGEST length)
{
gdb_assert (!value->lazy);

@@ -353,7 +354,8 @@ value_entirely_available (struct value *value)
}

void
-mark_value_bytes_unavailable (struct value *value, int offset, int length)
+mark_value_bytes_unavailable (struct value *value, LONGEST offset,
+ ULONGEST length)
{
range_s newr;
int i;
@@ -524,7 +526,7 @@ mark_value_bytes_unavailable (struct value *value, int offset, int length)

static int
find_first_range_overlap (VEC(range_s) *ranges, int pos,
- int offset, int length)
+ LONGEST offset, ULONGEST length)
{
range_s *r;
int i;
@@ -537,9 +539,9 @@ find_first_range_overlap (VEC(range_s) *ranges, int pos,
}

int
-value_available_contents_eq (const struct value *val1, int offset1,
- const struct value *val2, int offset2,
- int length)
+value_available_contents_eq (const struct value *val1, LONGEST offset1,
+ const struct value *val2, LONGEST offset2,
+ ULONGEST length)
{
int idx1 = 0, idx2 = 0;

@@ -767,13 +769,13 @@ deprecated_set_value_type (struct value *value, struct type *type)
value->type = type;
}

-int
+LONGEST
value_offset (const struct value *value)
{
return value->offset;
}
void
-set_value_offset (struct value *value, int offset)
+set_value_offset (struct value *value, LONGEST offset)
{
value->offset = offset;
}
@@ -924,8 +926,9 @@ value_contents_all (struct value *value)
DST_OFFSET+LENGTH) range are wholly available. */

void
-value_contents_copy_raw (struct value *dst, int dst_offset,
- struct value *src, int src_offset, int length)
+value_contents_copy_raw (struct value *dst, LONGEST dst_offset,
+ struct value *src, LONGEST src_offset,
+ ULONGEST length)
{
range_s *r;
int i;
@@ -973,8 +976,8 @@ value_contents_copy_raw (struct value *dst, int dst_offset,
DST_OFFSET+LENGTH) range are wholly available. */

void
-value_contents_copy (struct value *dst, int dst_offset,
- struct value *src, int src_offset, int length)
+value_contents_copy (struct value *dst, LONGEST dst_offset,
+ struct value *src, LONGEST src_offset, ULONGEST length)
{
require_not_optimized_out (src);

@@ -1034,7 +1037,7 @@ value_contents_equal (struct value *val1, struct value *val2)
{
struct type *type1;
struct type *type2;
- int len;
+ ULONGEST len;

type1 = check_typedef (value_type (val1));
type2 = check_typedef (value_type (val2));
@@ -1069,7 +1072,7 @@ value_entirely_optimized_out (const struct value *value)
}

int
-value_bits_valid (const struct value *value, int offset, int length)
+value_bits_valid (const struct value *value, LONGEST offset, ULONGEST length)
{
if (!value->optimized_out)
return 1;
@@ -1082,7 +1085,7 @@ value_bits_valid (const struct value *value, int offset, int length)

int
value_bits_synthetic_pointer (const struct value *value,
- int offset, int length)
+ LONGEST offset, ULONGEST length)
{
if (value->lval != lval_computed
|| !value->location.computed.funcs->check_synthetic_pointer)
@@ -1092,26 +1095,26 @@ value_bits_synthetic_pointer (const struct value *value,
length);
}

-int
+LONGEST
value_embedded_offset (struct value *value)
{
return value->embedded_offset;
}

void
-set_value_embedded_offset (struct value *value, int val)
+set_value_embedded_offset (struct value *value, LONGEST val)
{
value->embedded_offset = val;
}

-int
+LONGEST
value_pointed_to_offset (struct value *value)
{
return value->pointed_to_offset;
}

void
-set_value_pointed_to_offset (struct value *value, int val)
+set_value_pointed_to_offset (struct value *value, LONGEST val)
{
value->pointed_to_offset = val;
}
@@ -1914,7 +1917,7 @@ get_internalvar_function (struct internalvar *var,
}

void
-set_internalvar_component (struct internalvar *var, int offset, int bitpos,
+set_internalvar_component (struct internalvar *var, LONGEST offset, int bitpos,
int bitsize, struct value *newval)
{
gdb_byte *addr;
@@ -2583,7 +2586,7 @@ set_value_enclosing_type (struct value *val, struct type *new_encl_type)
FIELDNO says which field. */

struct value *
-value_primitive_field (struct value *arg1, int offset,
+value_primitive_field (struct value *arg1, LONGEST offset,
int fieldno, struct type *arg_type)
{
struct value *v;
@@ -2613,8 +2616,8 @@ value_primitive_field (struct value *arg1, int offset,
bit. Assume that the address, offset, and embedded offset
are sufficiently aligned. */

- int bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno);
- int container_bitsize = TYPE_LENGTH (type) * 8;
+ LONGEST bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno);
+ ULONGEST container_bitsize = TYPE_LENGTH (type) * 8;

v = allocate_value_lazy (type);
v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno);
@@ -2636,7 +2639,7 @@ value_primitive_field (struct value *arg1, int offset,
/* This field is actually a base subobject, so preserve the
entire object's contents for later references to virtual
bases, etc. */
- int boffset;
+ LONGEST boffset;

/* Lazy register values with offsets are not supported. */
if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))
@@ -2713,7 +2716,7 @@ value_field (struct value *arg1, int fieldno)
struct value *
value_fn_field (struct value **arg1p, struct fn_field *f,
int j, struct type *type,
- int offset)
+ LONGEST offset)
{
struct value *v;
struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
@@ -2773,8 +2776,8 @@ value_fn_field (struct value **arg1p, struct fn_field *f,

static int
unpack_value_bits_as_long_1 (struct type *field_type, const gdb_byte *valaddr,
- int embedded_offset, int bitpos, int bitsize,
- const struct value *original_value,
+ LONGEST embedded_offset, LONGEST bitpos,
+ int bitsize, const struct value *original_value,
LONGEST *result)
{
enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (field_type));
@@ -2782,7 +2785,7 @@ unpack_value_bits_as_long_1 (struct type *field_type, const gdb_byte *valaddr,
ULONGEST valmask;
int lsbcount;
int bytes_read;
- int read_offset;
+ LONGEST read_offset;

/* Read the minimum number of bytes required; there may not be
enough bytes to read an entire ULONGEST. */
@@ -2852,7 +2855,7 @@ unpack_value_bits_as_long_1 (struct type *field_type, const gdb_byte *valaddr,

int
unpack_value_bits_as_long (struct type *field_type, const gdb_byte *valaddr,
- int embedded_offset, int bitpos, int bitsize,
+ LONGEST embedded_offset, int bitpos, int bitsize,
const struct value *original_value,
LONGEST *result)
{
@@ -2870,10 +2873,10 @@ unpack_value_bits_as_long (struct type *field_type, const gdb_byte *valaddr,

static int
unpack_value_field_as_long_1 (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, int fieldno,
+ LONGEST embedded_offset, int fieldno,
const struct value *val, LONGEST *result)
{
- int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
+ LONGEST bitpos = TYPE_FIELD_BITPOS (type, fieldno);
int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
struct type *field_type = TYPE_FIELD_TYPE (type, fieldno);

@@ -2889,7 +2892,7 @@ unpack_value_field_as_long_1 (struct type *type, const gdb_byte *valaddr,

int
unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, int fieldno,
+ LONGEST embedded_offset, int fieldno,
const struct value *val, LONGEST *result)
{
gdb_assert (val != NULL);
@@ -2921,7 +2924,7 @@ unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno)
struct value *
value_field_bitfield (struct type *type, int fieldno,
const gdb_byte *valaddr,
- int embedded_offset, const struct value *val)
+ LONGEST embedded_offset, const struct value *val)
{
LONGEST l;

@@ -2948,12 +2951,12 @@ value_field_bitfield (struct type *type, int fieldno,

void
modify_field (struct type *type, gdb_byte *addr,
- LONGEST fieldval, int bitpos, int bitsize)
+ LONGEST fieldval, LONGEST bitpos, unsigned int bitsize)
{
enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
ULONGEST oword;
ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize);
- int bytesize;
+ ULONGEST bytesize;

/* Normalize BITPOS. */
addr += bitpos / 8;
diff --git a/gdb/value.h b/gdb/value.h
index 76c8e85..f953217 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -82,8 +82,8 @@ extern void set_value_parent (struct value *value, struct value *parent);
within the registers structure. Note also the member
embedded_offset below. */

-extern int value_offset (const struct value *);
-extern void set_value_offset (struct value *, int offset);
+extern LONGEST value_offset (const struct value *);
+extern void set_value_offset (struct value *, LONGEST offset);

/* The comment from "struct value" reads: ``Is it modifiable? Only
relevant if lval != not_lval.''. Shouldn't the value instead be
@@ -154,10 +154,10 @@ extern struct type *value_actual_type (struct value *value,
int resolve_simple_types,
int *real_type_found);

-extern int value_pointed_to_offset (struct value *value);
-extern void set_value_pointed_to_offset (struct value *value, int val);
-extern int value_embedded_offset (struct value *value);
-extern void set_value_embedded_offset (struct value *value, int val);
+extern LONGEST value_pointed_to_offset (struct value *value);
+extern void set_value_pointed_to_offset (struct value *value, LONGEST val);
+extern LONGEST value_embedded_offset (struct value *value);
+extern void set_value_embedded_offset (struct value *value, LONGEST val);

/* For lval_computed values, this structure holds functions used to
retrieve and set the value (or portions of the value).
@@ -185,7 +185,8 @@ struct lval_funcs
/* Check the validity of some bits in VALUE. This should return 1
if all the bits starting at OFFSET and extending for LENGTH bits
are valid, or 0 if any bit is invalid. */
- int (*check_validity) (const struct value *value, int offset, int length);
+ int (*check_validity) (const struct value *value, LONGEST offset,
+ ULONGEST length);

/* Return 1 if any bit in VALUE is valid, 0 if they are all invalid. */
int (*check_any_valid) (const struct value *value);
@@ -203,7 +204,7 @@ struct lval_funcs
/* If non-NULL, this is used to determine whether the indicated bits
of VALUE are a synthetic pointer. */
int (*check_synthetic_pointer) (const struct value *value,
- int offset, int length);
+ LONGEST offset, ULONGEST length);

/* Return a duplicate of VALUE's closure, for use in a new value.
This may simply return the same closure, if VALUE's is
@@ -240,7 +241,7 @@ extern struct value *allocate_computed_value (struct type *type,
Otherwise, return 1. */

extern int valprint_check_validity (struct ui_file *stream, struct type *type,
- int embedded_offset,
+ LONGEST embedded_offset,
const struct value *val);

extern struct value *allocate_optimized_out_value (struct type *type);
@@ -411,13 +412,13 @@ extern struct value *coerce_array (struct value *value);
bits in the given range are valid, zero if any bit is invalid. */

extern int value_bits_valid (const struct value *value,
- int offset, int length);
+ LONGEST offset, ULONGEST length);

/* Given a value, determine whether the bits starting at OFFSET and
extending for LENGTH bits are a synthetic pointer. */

extern int value_bits_synthetic_pointer (const struct value *value,
- int offset, int length);
+ LONGEST offset, ULONGEST length);

/* Given a value, determine whether the contents bytes starting at
OFFSET and extending for LENGTH bytes are available. This returns
@@ -425,7 +426,7 @@ extern int value_bits_synthetic_pointer (const struct value *value,
byte is unavailable. */

extern int value_bytes_available (const struct value *value,
- int offset, int length);
+ LONGEST offset, ULONGEST length);

/* Like value_bytes_available, but return false if any byte in the
whole object is unavailable. */
@@ -435,7 +436,7 @@ extern int value_entirely_available (struct value *value);
LENGTH bytes as unavailable. */

extern void mark_value_bytes_unavailable (struct value *value,
- int offset, int length);
+ LONGEST offset, ULONGEST length);

/* Compare LENGTH bytes of VAL1's contents starting at OFFSET1 with
LENGTH bytes of VAL2's contents starting at OFFSET2.
@@ -445,7 +446,7 @@ extern void mark_value_bytes_unavailable (struct value *value,
example, to compare a complete object value with itself, including
its enclosing type chunk, you'd do:

- int len = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
+ ULONGEST len = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
value_available_contents (val, 0, val, 0, len);

Returns true iff the set of available contents match. Unavailable
@@ -467,9 +468,10 @@ extern void mark_value_bytes_unavailable (struct value *value,
value_available_contents_eq(val, 3, val, 4, 4) => 0
*/

-extern int value_available_contents_eq (const struct value *val1, int offset1,
- const struct value *val2, int offset2,
- int length);
+extern int value_available_contents_eq (const struct value *val1,
+ LONGEST offset1,
+ const struct value *val2,
+ LONGEST offset2, ULONGEST length);

/* Read LENGTH bytes of memory starting at MEMADDR into BUFFER, which
is (or will be copied to) VAL's contents buffer offset by
@@ -480,7 +482,7 @@ extern int value_available_contents_eq (const struct value *val1, int offset1,

extern void read_value_memory (struct value *val, int embedded_offset,
int stack, CORE_ADDR memaddr,
- gdb_byte *buffer, size_t length);
+ gdb_byte *buffer, ULONGEST length);

\f

@@ -505,7 +507,7 @@ extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr);

extern int unpack_value_bits_as_long (struct type *field_type,
const gdb_byte *valaddr,
- int embedded_offset, int bitpos,
+ LONGEST embedded_offset, int bitpos,
int bitsize,
const struct value *original_value,
LONGEST *result);
@@ -514,12 +516,12 @@ extern LONGEST unpack_field_as_long (struct type *type,
const gdb_byte *valaddr,
int fieldno);
extern int unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, int fieldno,
+ LONGEST embedded_offset, int fieldno,
const struct value *val, LONGEST *result);

extern struct value *value_field_bitfield (struct type *type, int fieldno,
const gdb_byte *valaddr,
- int embedded_offset,
+ LONGEST embedded_offset,
const struct value *val);

extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num);
@@ -573,12 +575,12 @@ extern struct value *default_read_var_value (struct symbol *var,
extern struct value *allocate_value (struct type *type);
extern struct value *allocate_value_lazy (struct type *type);
extern void allocate_value_contents (struct value *value);
-extern void value_contents_copy (struct value *dst, int dst_offset,
- struct value *src, int src_offset,
- int length);
-extern void value_contents_copy_raw (struct value *dst, int dst_offset,
- struct value *src, int src_offset,
- int length);
+extern void value_contents_copy (struct value *dst, LONGEST dst_offset,
+ struct value *src, LONGEST src_offset,
+ ULONGEST length);
+extern void value_contents_copy_raw (struct value *dst, LONGEST dst_offset,
+ struct value *src, LONGEST src_offset,
+ ULONGEST length);

extern struct value *allocate_repeat_value (struct type *type, int count);

@@ -644,7 +646,8 @@ extern struct value *value_static_field (struct type *type, int fieldno);
extern struct fn_field *value_find_oload_method_list (struct value **,
const char *,
int, int *,
- struct type **, int *);
+ struct type **,
+ LONGEST *);

enum oload_search_type { NON_METHOD, METHOD, BOTH };

@@ -657,16 +660,16 @@ extern int find_overload_match (struct value **args, int nargs,

extern struct value *value_field (struct value *arg1, int fieldno);

-extern struct value *value_primitive_field (struct value *arg1, int offset,
+extern struct value *value_primitive_field (struct value *arg1, LONGEST offset,
int fieldno,
struct type *arg_type);

-extern struct type *value_rtti_indirect_type (struct value *, int *, int *,
+extern struct type *value_rtti_indirect_type (struct value *, int *, LONGEST *,
int *);

extern struct value *value_full_object (struct value *, struct type *, int,
- int, int);
+ LONGEST, int);

extern struct value *value_cast_pointers (struct type *, struct value *);

@@ -756,7 +759,7 @@ extern void set_internalvar_string (struct internalvar *var,
extern void clear_internalvar (struct internalvar *var);

extern void set_internalvar_component (struct internalvar *var,
- int offset,
+ LONGEST offset,
int bitpos, int bitsize,
struct value *newvalue);

@@ -836,7 +839,7 @@ extern struct value *value_x_unop (struct value *arg1, enum exp_opcode op,
enum noside noside);

extern struct value *value_fn_field (struct value **arg1p, struct fn_field *f,
- int j, struct type *type, int offset);
+ int j, struct type *type, LONGEST offset);

extern int binop_types_user_defined_p (enum exp_opcode op,
struct type *type1,
@@ -864,7 +867,8 @@ extern void release_value_or_incref (struct value *val);
extern int record_latest_value (struct value *val);

extern void modify_field (struct type *type, gdb_byte *addr,
- LONGEST fieldval, int bitpos, int bitsize);
+ LONGEST fieldval, LONGEST bitpos,
+ unsigned int bitsize);

extern void type_print (struct type *type, const char *varstring,
struct ui_file *stream, int show);
@@ -894,7 +898,7 @@ extern void value_print_array_elements (struct value *val,
extern struct value *value_release_to_mark (struct value *mark);

extern void val_print (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
+ LONGEST embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options,
@@ -945,7 +949,7 @@ extern struct value *value_literal_complex (struct value *, struct value *,
extern struct value *find_function_in_inferior (const char *,
struct objfile **);

-extern struct value *value_allocate_space_in_inferior (int);
+extern struct value *value_allocate_space_in_inferior (ULONGEST);

extern struct value *value_subscripted_rvalue (struct value *array,
LONGEST index, int lowerbound);
diff --git a/gdb/vax-tdep.c b/gdb/vax-tdep.c
index 0dcca75..378cf05 100644
--- a/gdb/vax-tdep.c
+++ b/gdb/vax-tdep.c
@@ -116,7 +116,7 @@ vax_store_arguments (struct regcache *regcache, int nargs,
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
gdb_byte buf[4];
- int count = 0;
+ ULONGEST count = 0;
int i;

/* We create an argument list on the stack, and make the argument
@@ -125,7 +125,7 @@ vax_store_arguments (struct regcache *regcache, int nargs,
/* Push arguments in reverse order. */
for (i = nargs - 1; i >= 0; i--)
{
- int len = TYPE_LENGTH (value_enclosing_type (args[i]));
+ ULONGEST len = TYPE_LENGTH (value_enclosing_type (args[i]));

sp -= (len + 3) & ~3;
count += (len + 3) / 4;
@@ -208,7 +208,7 @@ vax_return_value (struct gdbarch *gdbarch, struct type *func_type,
struct type *type, struct regcache *regcache,
gdb_byte *readbuf, const gdb_byte *writebuf)
{
- int len = TYPE_LENGTH (type);
+ ULONGEST len = TYPE_LENGTH (type);
gdb_byte buf[8];

if (TYPE_CODE (type) == TYPE_CODE_STRUCT
diff --git a/gdb/xstormy16-tdep.c b/gdb/xstormy16-tdep.c
index cfef755..c77e25d 100644
--- a/gdb/xstormy16-tdep.c
+++ b/gdb/xstormy16-tdep.c
@@ -162,8 +162,9 @@ static void
xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
void *valbuf)
{
- int len = TYPE_LENGTH (type);
- int i, regnum = E_1ST_ARG_REGNUM;
+ ULONGEST len = TYPE_LENGTH (type);
+ ULONGEST i;
+ int regnum = E_1ST_ARG_REGNUM;

for (i = 0; i < len; i += xstormy16_reg_size)
regcache_raw_read (regcache, regnum++, (char *) valbuf + i);
@@ -188,8 +189,9 @@ xstormy16_store_return_value (struct type *type, struct regcache *regcache,
}
else
{
- int len = TYPE_LENGTH (type);
- int i, regnum = E_1ST_ARG_REGNUM;
+ ULONGEST len = TYPE_LENGTH (type);
+ ULONGEST i;
+ int regnum = E_1ST_ARG_REGNUM;

for (i = 0; i < len; i += xstormy16_reg_size)
regcache_raw_write (regcache, regnum++, (char *) valbuf + i);
@@ -235,8 +237,9 @@ xstormy16_push_dummy_call (struct gdbarch *gdbarch,
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR stack_dest = sp;
int argreg = E_1ST_ARG_REGNUM;
- int i, j;
- int typelen, slacklen;
+ int i, slacklen;
+ LONGEST j;
+ ULONGEST typelen;
const gdb_byte *val;
char buf[xstormy16_pc_size];

diff --git a/gdb/xtensa-tdep.c b/gdb/xtensa-tdep.c
index 78d8888..79308b7 100644
--- a/gdb/xtensa-tdep.c
+++ b/gdb/xtensa-tdep.c
@@ -1581,7 +1581,7 @@ xtensa_extract_return_value (struct type *type,
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
bfd_byte *valbuf = dst;
- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);
ULONGEST pc, wb;
int callsize, areg;
int offset = 0;
@@ -1599,8 +1599,8 @@ xtensa_extract_return_value (struct type *type,
/* On Xtensa, we can return up to 4 words (or 2 for call12). */
if (len > (callsize > 8 ? 8 : 16))
internal_error (__FILE__, __LINE__,
- _("cannot extract return value of %d bytes long"),
- len);
+ _("cannot extract return value of %s bytes long"),
+ pulongest (len));

/* Get the register offset of the return
register (A2) in the caller window. */
@@ -1615,7 +1615,8 @@ xtensa_extract_return_value (struct type *type,
areg = gdbarch_tdep (gdbarch)->a0_base + C0_ARGS;
}

- DEBUGINFO ("[xtensa_extract_return_value] areg %d len %d\n", areg, len);
+ DEBUGINFO ("[xtensa_extract_return_value] areg %d len %s\n", areg,
+ pulongest (len));

if (len < 4 && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
offset = 4 - len;
@@ -1640,7 +1641,7 @@ xtensa_store_return_value (struct type *type,
unsigned int areg;
ULONGEST pc, wb;
int callsize;
- int len = TYPE_LENGTH (type);
+ LONGEST len = TYPE_LENGTH (type);
int offset = 0;

DEBUGTRACE ("xtensa_store_return_value (...)\n");
@@ -1654,8 +1655,8 @@ xtensa_store_return_value (struct type *type,

if (len > (callsize > 8 ? 8 : 16))
internal_error (__FILE__, __LINE__,
- _("unimplemented for this length: %d"),
- TYPE_LENGTH (type));
+ _("unimplemented for this length: %s"),
+ pulongest (TYPE_LENGTH (type)));
areg = arreg_number (gdbarch,
gdbarch_tdep (gdbarch)->a0_base + 2 + callsize, wb);

@@ -1729,18 +1730,18 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch,
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int i;
- int size, onstack_size;
+ ULONGEST size, onstack_size;
gdb_byte *buf = (gdb_byte *) alloca (16);
CORE_ADDR ra, ps;
struct argument_info
{
const bfd_byte *contents;
- int length;
+ ULONGEST length;
int onstack; /* onstack == 0 => in reg */
int align; /* alignment */
union
{
- int offset; /* stack offset if on stack. */
+ LONGEST offset; /* stack offset if on stack. */
int regno; /* regno if in register. */
} u;
};
@@ -1764,9 +1765,9 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch,
{
struct value *arg = args[i];
struct type *arg_type = check_typedef (value_type (arg));
- fprintf_unfiltered (gdb_stdlog, "%2d: %s %3d ", i,
+ fprintf_unfiltered (gdb_stdlog, "%2d: %s %s ", i,
host_address_to_string (arg),
- TYPE_LENGTH (arg_type));
+ pulongest (TYPE_LENGTH (arg_type)));
switch (TYPE_CODE (arg_type))
{
case TYPE_CODE_INT:

[-- Attachment #3: bitpos-expand-testcase.patch --]
[-- Type: text/x-patch, Size: 2557 bytes --]

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