Re: [2/2][PATCH v3] Expand bitpos and type.length to LONGEST and ULONGEST

Siddhesh Poyarekar
2012-06-18T10:31:34Z

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

This is part 2/2, which has the script and output that I will be using
for the review.

regards,
Siddhesh

[-- Attachment #2: process-locdiff --]
[-- Type: application/octet-stream, Size: 7752 bytes --]

#! /usr/bin/perl
use strict;
use warnings;

@ARGV==1 or die;

sub readfile($)
{
my($fname)=@_;

local *F;
open F,$fname or die $fname;
my $F=do { local $/; <F>; };
defined $F or die $fname;
close F or die $fname;
return $F;
}

# Figure out which changes are safe based on the warnings before and after the
# change. We could simply check $f[1] and $t[1] for compatibility of types,
# but checking both the old and new changes allows us to retain places where we
# have accidentally changed signs.
sub safe_change($$) {
my($ref_from, $ref_to) = @_;
my @f = @{$ref_from};
my @t = @{$ref_to};

# It is OK if the warnings before and after were only for the sign of
# the assignment or comparison.
if ($f[0] eq "int" && $f[1] eq "LONGEST" &&
$t[0] eq "UINT" && $t[1] eq "ULONGEST") {
return 1;
}

# Likewise for reverse sign.
if ($f[0] eq "UINT" && $f[1] eq "ULONGEST" &&
$t[0] eq "int" && $t[1] eq "LONGEST") {
return 1;
}

# If the earlier the target was larger but with a different sign and
# now we have the same size but different sign, then we're still OK.
if ($f[0] eq "int" && $f[1] eq "LONGEST" &&
$t[0] eq "ULONGEST" && $t[1] eq "ULONGEST") {
return 1;
}

# Likewise for reverse sign.
if ($f[0] eq "UINT" && $f[1] eq "ULONGEST" &&
$t[0] eq "LONGEST" && $t[1] eq "LONGEST") {
return 1;
}

# If the earlier the target was smaller but with a different sign and
# now we have the same size but different sign then we have actually
# fixed something.
if ($f[0] eq "LONGEST" && $f[1] eq "LONGEST" &&
$t[0] eq "UINT" && $t[1] eq "ULONGEST") {
return 1;
}

# Likewise for reverse sign.
if ($f[0] eq "ULONGEST" && $f[1] eq "ULONGEST" &&
$t[0] eq "int" && $t[1] eq "LONGEST") {
return 1;
}

# If we simply grew the target type without changing the sign, we're
# fine there too.
if ($f[0] eq "UINT" && $f[1] eq "UINT" &&
$t[0] eq "int" && $t[1] eq "LONGEST") {
return 1;
}

# Likewise for reverse sign.
if ($f[0] eq "int" && $f[1] eq "int" &&
$t[0] eq "UINT" && $t[1] eq "ULONGEST") {
return 1;
}

# Similar logic for (s)size_t. size_t will always be smaller than or
# equal to LONGEST/ULONGEST, so treat it as if it were smaller and use
# the same logic as above.
if ($f[0] eq "size_t" && $f[1] eq "size_t" &&
$t[0] eq "int" && $t[1] eq "LONGEST") {
return 1;
}

if ($f[0] eq "size_t" && $f[1] eq "ULONGEST" &&
$t[0] eq "LONGEST" && $t[1] eq "LONGEST") {
return 1;
}

if ($f[0] eq "ssize_t" && $f[1] eq "ssize_t" &&
$t[0] eq "UINT" && $t[1] eq "ULONGEST") {
return 1;
}

if ($f[0] eq "ssize_t" && $f[1] eq "LONGEST" &&
$t[0] eq "ULONGEST" && $t[1] eq "ULONGEST") {
return 1;
}

return 0;
}

# Read in the file and prepare it so that we can run our future regexes easily.
my $f = readfile $ARGV[0];

$f=~s{unsigned long int}{"ULONGEST";}egm;
$f=~s{long int}{"LONGEST";}egm;
$f=~s{unsigned int}{"UINT";}egm;

# 0 = Assignment of...
# 1 = Function <func> expects arg <num>...
# 2 = Function *signed_integer expects arg 2...
# 3 = Variable initialized to type ...
my $match = -1;

my $look = -1;
my @savelines;
my @from;
my @to;
my @expr;
my @var;
my @argnum;

# Walk through the file.
LINE: for(split /^/, $f) {
my $line = $_;

# Skip blank lines
next LINE if /^\s*$/;
# Skip summary lines
next LINE if /^[-+]Finished checking/;
# Skip command warnings.
next LINE if /^ Command Line: Setting/;
next LINE if /^ Splint 3\.1\.2 ---/;

# Found a LOC. We look at the next lines.
if ($look < 0 && /^\s+LOC/) {
push @savelines, $_;
$look = 0;
next LINE;
}
# We're looking at the next lines.
elsif ($look >= 0) {
my $l = $_;

# Make sure that the type promotions are safe. See safe_change
# for details
if (($look == 0 || $match == 0) && /Assignment of (\w+) to (\w+):(.*)$/) {
push @from, $1;
push @to, $2;
push @expr, $3;
push @savelines, $l;
$line = "";
$look += 1;
$match = 0;

next LINE if $look == 1;

# only if we're talking about the same expression
if (($expr[0] eq $expr[1]) && safe_change (\@from, \@to)) {
# Skip the changeset.
$#savelines = -1;
}
goto done;
}

# The (store|extract)_(un)?signed_integer functions always have
# a primitive size in arg 2 and hence this warning is moot for
# this change..
if (($look == 0 || $match == 2) && /Function ((extract)|(store))?_(long_)?(un)?signed_integer expects arg 2 to be int/) {
$line = "";
push @savelines, $l;
$look += 1;
$match = 2;
next LINE if $look == 1;
$#savelines = -1;
goto done;
}

# Analogous change to the Assignment change above. Again, see
# safe_change function for details.
if (($look == 0 || $match == 1) && /Function (\w+) expects arg (\d) to be (\w+) gets (\w+): (.*)$/) {
push @var, $1;
push @argnum, $2;
push @to, $3;
push @from, $4;
push @expr, $5;
push @savelines, $l;
$line = "";
$look += 1;
$match = 1;

next LINE if $look == 1;

# only if we're talking about the same expression
if (($expr[0] eq $expr[1]) &&
($var[0] eq $var[1]) &&
($argnum[0] eq $argnum[1]) &&
(safe_change (\@from, \@to))) {
# Skip the changeset.
$#savelines = -1;
}
goto done;
}

# Analogous change to the Function change above.
if (($look == 0 || $match == 3) && /Variable (\w+) initialized to type (\w+), expects (\w+): (.*)$/) {
push @var, $1;
push @to, $3;
push @from, $2;
push @expr, $4;
push @savelines, $l;
$line = "";
$look += 1;
$match = 3;

next LINE if $look == 1;

# only if we're talking about the same expression
if (($expr[0] eq $expr[1]) &&
($var[0] eq $var[1]) &&
(safe_change (\@from, \@to))) {
# Skip the changeset.
$#savelines = -1;
}
goto done;
}

# Skip non-boolean warnings.
if (($look == 0 || $match == 4) && /Test expression for (\w+) not boolean/) {
$line = "";
push @savelines, $l;
$look += 1;
$match = 4;
next LINE if $look == 1;
$#savelines = -1;
goto done;
}

# These warnings are again not a result of our change.
if (($look == 0 || $match == 5) && /New fresh storage \(type (\w+) \*\) passed as implicitly temp/) {
$line = "";
push @savelines, $l;
$look += 1;
$match = 5;
next LINE if $look == 1;
$#savelines = -1;
goto done;
}

if (($look == 0 || $match == 6) && /Operands of ([^\s]+) have incompatible types \((\w+), (\w+)\): (.*)$/) {
push @var, $1;
push @to, $2;
push @from, $3;
push @expr, $4;
push @savelines, $l;
$line = "";
$look += 1;
$match = 6;

next LINE if $look == 1;

# ULONGEST to LONGEST comparisons are safe.
if (($expr[0] eq $expr[1]) &&
(($from[1] eq "LONGEST" && $to[1] eq "ULONGEST") ||
($from[1] eq "ULONGEST" && $to[1] eq "LONGEST"))
) {
# Skip the changeset.
$#savelines = -1;
}
goto done;
}

# Remove blocks that are not really changes at all
# We only drop complete blocks, i.e. something that is nested by
# two LOC lines and the first LOC is preceded by a space.
if ($look == 0 || $match == 7) {
# Got the next LOC.
if (/^([ -+])\s*LOC/) {
$#savelines = -1;
push @savelines, $l;
if ($1 eq " ") {
$look = 0;
$match = -1;
next LINE;
}
}
# Anything else, we just schedule to remove.
elsif (/^ /) {
$line = "";
push @savelines, $l;
$look += 1;
$match = 7;
next LINE;
}

goto done;
}

}

# The next lines didn't work out as expected, so clear and print
# everything out as if nothing happened.
done: $look = -1;
foreach(@savelines) {
print $_;
}
print $line;
$#savelines = -1;
$#var = -1;
$#argnum = -1;
$#from = -1;
$#to = -1;
$#expr = -1;
}

[-- Attachment #3: locdiff.processed.out --]
[-- Type: application/octet-stream, Size: 137942 bytes --]

--- /tmp/locdiff.9926.a 2012-06-18 14:55:12.760242020 +0530
+++ /tmp/locdiff.9926.b 2012-06-18 14:55:13.402242035 +0530
@@ -1,384543 +1,384866 @@
LOC ada-lang.c:579 (ada-lang.c:578)
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC ada-lang.c:670 (ada-lang.c:669)
- Function umax_of_size expects arg 1 to be int gets UINT: (t)->length
+ Function umax_of_size expects arg 1 to be int gets ULONGEST: (t)->length
LOC ada-lang.c:672 (ada-lang.c:671)
- Function max_of_size expects arg 1 to be int gets UINT: (t)->length
+ Function max_of_size expects arg 1 to be int gets ULONGEST: (t)->length
ada-lang.c: (in function min_of_type)
LOC ada-lang.c:682 (ada-lang.c:681)
- Function min_of_size expects arg 1 to be int gets UINT: (t)->length
+ Function min_of_size expects arg 1 to be int gets ULONGEST: (t)->length
ada-lang.c: (in function ada_discrete_type_high_bound)
LOC ada-lang.c:1622 (ada-lang.c:1621)
- Return value type UINT does not match declared type int: 8 * (ada_check_typedef((((type)->main_type->flds_bnds.fields[1]).type)))->length
+ Return value type ULONGEST does not match declared type int: 8 * (ada_check_typedef((((type)->main_type->flds_bnds.fields[1]).type)))->length
LOC ada-lang.c:1688 (ada-lang.c:1687)
- Return value type UINT does not match declared type int: 8 * ((((type)->main_type->flds_bnds.fields[0]).type))->length
+ Return value type ULONGEST does not match declared type int: 8 * ((((type)->main_type->flds_bnds.fields[0]).type))->length
LOC ada-lang.c:1724 (ada-lang.c:1723)
- Return value type UINT does not match declared type int: 8 * ((((type)->main_type->flds_bnds.fields[2 * i + which - 2]).type))->length
+ Return value type ULONGEST does not match declared type int: 8 * ((((type)->main_type->flds_bnds.fields[2 * i + which - 2]).type))->length
LOC ada-lang.c:1899 (ada-lang.c:1896)
- Variable array_bitsize initialized to type LONGEST, expects int: (hi - lo + 1) * (((elt_type)->main_type->flds_bnds.fields[0]).bitsize)
-LOC ada-lang.c:1898
- Assignment of int to UINT: (array_type)->length = (array_bitsize + 7) / 8
+ Assignment of LONGEST to ULONGEST: (array_type)->length = (array_bitsize + 7) / 8
+LOC ada-lang.c:2185
+ Function ada_value_primitive_packed_val expects arg 4 to be int gets LONGEST: bit_pos % 8
LOC ada-lang.c:2338 (ada-lang.c:2322)
- Function set_value_offset expects arg 2 to be int gets LONGEST: new_offset
-LOC ada-lang.c:2335
- Assignment of UINT to int: ntarg = (type)->length
+ Assignment of ULONGEST to LONGEST: ntarg = (type)->length
LOC ada-lang.c:2342 (ada-lang.c:2339)
- Function memset expects arg 3 to be size_t gets UINT: (type)->length
+ Function memset expects arg 3 to be size_t gets ULONGEST: (type)->length
+LOC ada-lang.c:2379
+ Assignment of LONGEST to int: src = targ = 0
LOC ada-lang.c:2445 (ada-lang.c:2448)
+ Assignment of LONGEST to int: accum_bits = 8 - src_offset
+LOC ada-lang.c:2451
Incompatible types for + (UINT, unsigned char): (accum << 8) + (unsigned char)*source
LOC ada-lang.c:2455
+ Operands of > have incompatible types (int, LONGEST): chunk_size > n
+LOC ada-lang.c:2456
+ Assignment of LONGEST to int: chunk_size = n
+LOC ada-lang.c:2458
Right operand of << may be negative (int): 1 << chunk_size
LOC ada-lang.c:2470 (ada-lang.c:2467)
- Right operand of >> may be negative (int): (unsigned char)*source >> src_offset
+ Right operand of >> may be negative (LONGEST): (unsigned char)*source >> src_offset
LOC ada-lang.c:2470 (ada-lang.c:2467)
- Assignment of unsigned char to UINT: accum = (unsigned char)*source >> src_offset
+ Assignment of LONGEST to UINT: accum = (unsigned char)*source >> src_offset
+LOC ada-lang.c:2472
+ Assignment of LONGEST to int: accum_bits = 8 - src_offset
LOC ada-lang.c:2480 (ada-lang.c:2479)
+ Operands of > have incompatible types (int, LONGEST): chunk_size > n
+LOC ada-lang.c:2481
+ Assignment of LONGEST to int: chunk_size = n
+LOC ada-lang.c:2482
Right operand of << may be negative (int): 1 << chunk_size
LOC ada-lang.c:2545 (ada-lang.c:2542)
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC ada-lang.c:4094 (ada-lang.c:4091)
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC ada-lang.c:4138 (ada-lang.c:4135)
- Function memcpy expects arg 3 to be size_t gets UINT: (actual_type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (actual_type)->length
LOC ada-lang.c:4163 (ada-lang.c:4160)
- Function C_alloca expects arg 1 to be size_t gets UINT: len
+ Function C_alloca expects arg 1 to be size_t gets ULONGEST: len
LOC ada-lang.c:6431 (ada-lang.c:6426)
+ Function ada_value_primitive_packed_val expects arg 4 to be int gets LONGEST: bit_pos % 8
+LOC ada-lang.c:6429
New fresh storage (type gdb_byte *) passed as implicitly temp (not released): value_contents(arg1)
LOC ada-lang.c:6489
+ Assignment of LONGEST to int: *bit_offset_p = bit_pos % 8
+LOC ada-lang.c:6492
Fresh storage type not released before return
LOC ada-lang.c:7430 (ada-lang.c:7427)
- Assignment of UINT to LONGEST: off = align_value(off, field_alignment(type, f)) + ((((type)->main_type->flds_bnds.fields[f]).loc.bitpos) + 0)
-LOC ada-lang.c:7429
- Assignment of LONGEST to int: (((rtype)->main_type->flds_bnds.fields[f]).loc.bitpos) = (off)
+ Assignment of ULONGEST to LONGEST: off = align_value(off, field_alignment(type, f)) + ((((type)->main_type->flds_bnds.fields[f]).loc.bitpos) + 0)
LOC ada-lang.c:7524 (ada-lang.c:7521)
- Assignment of UINT to int: fld_bit_len = (((rtype)->main_type->flds_bnds.fields[f]).bitsize) = (((type)->main_type->flds_bnds.fields[f]).bitsize)
-LOC ada-lang.c:7524
- Assignment of UINT to int: fld_bit_len = (ada_check_typedef(field_type))->length * 8
+ Assignment of UINT to LONGEST: fld_bit_len = (((rtype)->main_type->flds_bnds.fields[f]).bitsize) = (((type)->main_type->flds_bnds.fields[f]).bitsize)
LOC ada-lang.c:7527 (ada-lang.c:7528)
- Assignment of LONGEST to int: bit_len = off + fld_bit_len
+ Assignment of ULONGEST to LONGEST: fld_bit_len = (ada_check_typedef(field_type))->length * 8
LOC ada-lang.c:7573 (ada-lang.c:7568)
- Assignment of LONGEST to int: bit_len = off + fld_bit_len
-LOC ada-lang.c:7570
- Function align_value expects arg 1 to be UINT gets int: bit_len
+ Function align_value expects arg 1 to be ULONGEST gets LONGEST: bit_len
LOC ada-lang.c:7927 (ada-lang.c:7924)
- Variable len initialized to type UINT, expects int: (result)->length / ((result)->main_type->target_type)->length
+ Variable len initialized to type ULONGEST, expects LONGEST: ((result)->length / ((result)->main_type->target_type)->length)
LOC ada-lang.c:8739 (ada-lang.c:8735)
- Function memcmp expects arg 3 to be size_t gets UINT: (value_type(arg1))->length
+ Function memcmp expects arg 3 to be size_t gets ULONGEST: (value_type(arg1))->length
LOC ada-lang.c:8794 (ada-lang.c:8790)
- Function ada_index_struct_field expects arg 1 to be int gets LONGEST: index
-LOC ada-lang.c:8790
New fresh storage (type struct type *) passed as implicitly temp (not released): value_type(lhs)
LOC ada-valprint.c:376
- Function ada_emit_char expects arg 5 to be int gets UINT: (type)->length
+ Function ada_emit_char expects arg 5 to be int gets ULONGEST: (type)->length
ada-valprint.c: (in function ada_print_scalar)
LOC ada-valprint.c:483 (ada-valprint.c:491)
+ Operands of < have incompatible types (UINT, ULONGEST): i < length
+LOC ada-valprint.c:491
Test expression for if not boolean, type int: quit_flag
LOC ada-valprint.c:501 (ada-valprint.c:502)
- Function char_at expects arg 2 to be int gets UINT: rep1
+ Operands of < have incompatible types (UINT, ULONGEST): rep1 < length
+LOC ada-valprint.c:502
+ Function char_at expects arg 2 to be LONGEST gets UINT: rep1
LOC ada-valprint.c:553
+ Operands of < have incompatible types (UINT, ULONGEST): i < length
+LOC ada-valprint.c:553
Left operand of || is non-boolean (int): force_ellipses || i < length
ada-valprint.c: (in function ada_printstr)
LOC ada-valprint.c:563
- Function printstr expects arg 6 to be int gets UINT: (type)->length
+ Function printstr expects arg 6 to be int gets ULONGEST: (type)->length
LOC ada-valprint.c:629
- Operands of < have incompatible types (int, UINT): temp_len < options->print_max
+ Operands of < have incompatible types (LONGEST, UINT): temp_len < options->print_max
LOC ada-valprint.c:631
- Function char_at expects arg 3 to be int gets UINT: eltlen
+ Function char_at expects arg 3 to be int gets ULONGEST: eltlen
LOC ada-valprint.c:636
- Function printstr expects arg 6 to be int gets UINT: eltlen
+ Function printstr expects arg 6 to be int gets ULONGEST: eltlen
LOC ada-valprint.c:964
- Operands of != have incompatible types (UINT, size_t): ((type)->main_type->target_type)->length != sizeof(char)
+ Operands of != have incompatible types (ULONGEST, size_t): ((type)->main_type->target_type)->length != sizeof(char)
LOC ada-valprint.c:1132 (ada-valprint.c:1130)
+ Function ada_value_primitive_packed_val expects arg 4 to be int gets LONGEST: bit_pos % 8
+LOC ada-valprint.c:1130
Null storage passed as non-null param: ada_value_primitive_packed_val (NULL, ...)
+LOC alpha-tdep.c:402
+ Assignment of LONGEST to int: accumulate_size = (accumulate_size + m_arg->len + 7) & ~7
LOC alpha-tdep.c:432
- Operands of <= have incompatible types (int, size_t): offset + len <= sizeof((arg_reg_buffer))
+ Operands of <= have incompatible types (LONGEST, size_t): offset + len <= sizeof((arg_reg_buffer))
LOC alpha-tdep.c:434
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC alpha-tdep.c:448
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC alpha-tdep.c:534 (alpha-tdep.c:537)
+ Function store_unsigned_integer expects arg 2 to be int gets LONGEST: length
+LOC alpha-tdep.c:537
Fresh storage gdbarch not released before return
LOC alpha-tdep.c:630
- Function read_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function read_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
amd64-tdep.c: (in function amd64_return_value)
LOC amd64-tdep.c:635
- Function read_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function read_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC amd64-tdep.c:698
+ Function regcache_raw_read_part expects arg 4 to be int gets LONGEST: ((len) < (8) ? (len) : (8))
+LOC amd64-tdep.c:698
Return value (type enum register_status) ignored: regcache_raw_rea...
LOC amd64-tdep.c:701 (amd64-tdep.c:705)
+ Function regcache_raw_write_part expects arg 4 to be int gets LONGEST: ((len) < (8) ? (len) : (8))
+LOC amd64-tdep.c:705
Fresh storage tdep not released before return
LOC amd64-tdep.c:824
- Function memcpy expects arg 3 to be size_t gets int: ((len) < (8) ? (len) : (8))
+ Function memcpy expects arg 3 to be size_t gets LONGEST: ((len) < (8) ? (len) : (8))
LOC amd64-tdep.c:845
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC amd64-tdep.c:2777
- Function target_read_memory expects arg 3 to be ssize_t gets int: len
+ Function target_read_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC amd64-windows-tdep.c:111
- Function read_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function read_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
+LOC amd64-windows-tdep.c:119
+ Function regcache_raw_read_part expects arg 4 to be int gets LONGEST: len
LOC amd64-windows-tdep.c:121 (amd64-windows-tdep.c:77)
+ Function regcache_raw_write_part expects arg 4 to be int gets LONGEST: len
+LOC amd64-windows-tdep.c:77
Parameter gdbarch not used
LOC arm-linux-nat.c:932
- Right operand of << may be negative (int): 1 << len
+ Right operand of << may be negative (LONGEST): 1 << len
LOC arm-linux-nat.c:932
- Assignment of int to UINT: mask = (1 << len) - 1
+ Assignment of LONGEST to UINT: mask = (1 << len) - 1
LOC arm-tdep.c:3289
- Return value type UINT does not match declared type int: (t)->length
+ Return value type ULONGEST does not match declared type int: (t)->length
LOC arm-tdep.c:3422
- Return value type UINT does not match declared type int: (t)->length / unitlen
+ Return value type ULONGEST does not match declared type int: (t)->length / unitlen
LOC arm-tdep.c:3689 (arm-tdep.c:3690)
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC arm-tdep.c:3690
Test expression for if not boolean, type int: arm_pc_is_thumb(gdbarch, regval)
LOC arm-tdep.c:3692
- Function C_alloca expects arg 1 to be size_t gets int: len
+ Function C_alloca expects arg 1 to be size_t gets LONGEST: len
+LOC arm-tdep.c:3693
+ Function store_unsigned_integer expects arg 2 to be int gets LONGEST: len
LOC arm-tdep.c:3704 (arm-tdep.c:3706)
+ Variable partial_len initialized to type LONGEST, expects int: len < 4 ? len : 4
+LOC arm-tdep.c:3706
Left operand of && is non-boolean (int): may_use_core_reg && argreg <= ARM_LAST_ARG_REGNUM
avr-tdep.c: (in function avr_pointer_to_address)
LOC avr-tdep.c:932 (avr-tdep.c:937)
- Operands of < have incompatible types (int, UINT): i < (valtype)->length
+ Function regcache_cooked_write expects arg 2 to be int gets LONGEST: lsb_reg + i
+LOC avr-tdep.c:937
+ Operands of < have incompatible types (LONGEST, ULONGEST): i < (valtype)->length
LOC avr-tdep.c:938
+ Function regcache_cooked_read expects arg 2 to be int gets LONGEST: lsb_reg + i
+LOC avr-tdep.c:938
Return value (type enum register_status) ignored: regcache_cooked_...
LOC avr-tdep.c:1184 (avr-tdep.c:1183)
- Function xmalloc expects arg 1 to be size_t gets int: len
+ Function xmalloc expects arg 1 to be size_t gets LONGEST: len
LOC avr-tdep.c:1185
+ Assignment of LONGEST to int: si->len = len
+LOC avr-tdep.c:1186
Implicitly only storage si->prev (type struct stack_item *) not released before assignment: si->prev = prev
LOC avr-tdep.c:1187 (avr-tdep.c:1186)
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
avr-tdep.c: (in function avr_push_dummy_call)
+LOC avr-tdep.c:1286
+ Test expression for if not boolean, type LONGEST: len & 1
LOC avr-tdep.c:1289 (avr-tdep.c:1285)
- Test expression for if not boolean, type int: len & 1
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
LOC avr-tdep.c:1290 (avr-tdep.c:1291)
- Right operand of >> may be negative (int): val >> (8 * (len - j - 1))
+ Operands of < have incompatible types (int, LONGEST): j < len
+LOC avr-tdep.c:1292
+ Right operand of >> may be negative (LONGEST): val >> (8 * (len - j - 1))
LOC ax-gdb.c:486 (ax-gdb.c:485)
- Function ax_ext expects arg 2 to be int gets UINT: (type)->length * 8
+ Function ax_ext expects arg 2 to be int gets ULONGEST: (type)->length * 8
ax-gdb.c: (in function gen_extend)
LOC ax-gdb.c:496 (ax-gdb.c:495)
- Variable bits initialized to type UINT, expects int: (type)->length * 8
+ Variable bits initialized to type ULONGEST, expects int: (type)->length * 8
LOC ax-gdb.c:512 (ax-gdb.c:511)
- Function ax_trace_quick expects arg 2 to be int gets UINT: (type)->length
+ Function ax_trace_quick expects arg 2 to be int gets ULONGEST: (type)->length
-LOC ax-gdb.c:597
- Function gen_offset expects arg 2 to be int gets LONGEST: frame_offset
ax-gdb.c: (in function gen_frame_locals_address)
-LOC ax-gdb.c:612
- Function gen_offset expects arg 2 to be int gets LONGEST: frame_offset
-ax-gdb.c: (in function gen_sym_offset)
-LOC ax-gdb.c:646
- Function gen_offset expects arg 2 to be int gets LONGEST: (var)->ginfo.value.ivalue
ax-gdb.c: (in function gen_var_ref)
ax-gdb.c: (in function gen_ptradd)
LOC ax-gdb.c:1424 (ax-gdb.c:1427)
+ Function expects arg 2 to be int gets LONGEST: end - start
+LOC ax-gdb.c:1428
Implicitly only storage value->type (type struct type *) not released before assignment: value->type = type
ax-gdb.c: (in function gen_primitive_field)
LOC bfin-tdep.c:538
- Function write_memory expects arg 3 to be ssize_t gets int: container_len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: container_len
LOC breakpoint.c:2169 (breakpoint.c:2175)
+ Assignment of LONGEST to int: bl->target_info.length = bl->length
+LOC breakpoint.c:2176
Test expression for if not boolean, type int: is_breakpoint(bl->owner)
LOC breakpoint.c:4390 (breakpoint.c:4387)
+ Function expects arg 4 to be int gets LONGEST: loc->length
+LOC breakpoint.c:4388
Test expression for if not boolean, type int: (*&current_target.to_watchpoint_addr_within_range)(&current_target, addr, loc->address, loc->length)
LOC breakpoint.c:6365 (breakpoint.c:6362)
- Operands of && are non-boolean (int): bl->length && breakpoint_address_match_range(bl->pspace->aspace, bl->address, bl->length, aspace, addr)
+ Function breakpoint_address_match_range expects arg 3 to be int gets LONGEST: bl->length
+LOC breakpoint.c:6363
+ Operands of && are non-booleans (LONGEST, int): bl->length && breakpoint_address_match_range(bl->pspace->aspace, bl->address, bl->length, aspace, addr)
LOC breakpoint.c:9486 (breakpoint.c:9485)
Return value (type int) ignored: create_breakpoin...
+breakpoint.c: (in function breakpoint_hit_ranged_breakpoint)
+LOC breakpoint.c:9513
+ Function breakpoint_address_match_range expects arg 3 to be int gets LONGEST: bl->length
breakpoint.c: (in function resources_needed_ranged_breakpoint)
LOC breakpoint.c:15558 (breakpoint.c:15557)
- Function observer_attach_memory_changed expects arg 1 to be observer_memory_changed_ftype * gets [function (CORE_ADDR, int, bfd_byte *) returns void]: invalidate_bp_value_on_memory_change
+ Function observer_attach_memory_changed expects arg 1 to be observer_memory_changed_ftype * gets [function (CORE_ADDR, LONGEST, bfd_byte *) returns void]: invalidate_bp_value_on_memory_change
LOC c-lang.c:205
- Variable width initialized to type UINT, expects int: (type)->length
+ Variable width initialized to type ULONGEST, expects int: (type)->length
LOC c-lang.c:292
- Assignment of UINT to int: width = (element_type)->length
+ Assignment of ULONGEST to int: width = (element_type)->length
LOC c-lang.c:418
- Function C_alloca expects arg 1 to be size_t gets UINT: (type)->length
+ Function C_alloca expects arg 1 to be size_t gets ULONGEST: (type)->length
LOC c-lang.c:674 (c-lang.c:675)
+ Operands of != have incompatible types (UINT, ULONGEST): (UINT)((&output)->next_free - (&output)->object_base) != (type)->length
+LOC c-lang.c:675
New fresh storage (type char *) passed as implicitly temp (not released): gettext("Could not convert character "
"constant to target character set")
LOC c-lang.c:697
- Assignment of UINT to LONGEST: high_bound = ((expect_type)->length / element_size) - 1
-LOC c-lang.c:699
- Operands of > have incompatible types (UINT, LONGEST): (UINT)((&output)->next_free - (&output)->object_base) / element_size > (high_bound - low_bound + 1)
+ Assignment of ULONGEST to LONGEST: high_bound = ((expect_type)->length / element_size) - 1
LOC cp-abi.c:96
- Path with no return in function declared to return int
+ Path with no return in function declared to return LONGEST
LOC cp-valprint.c:363 (cp-valprint.c:366)
+ Variable i_offset initialized to type LONGEST, expects int: offset + ((((type)->main_type->flds_bnds.fields[i]).loc.bitpos) + 0) / 8
+LOC cp-valprint.c:366
Test expression for if not boolean, type int: valprint_check_validity(stream, i_type, i_offset, val)
LOC cp-valprint.c:560 (cp-valprint.c:559)
- Function C_alloca expects arg 1 to be size_t gets UINT: (baseclass)->length
+ Function C_alloca expects arg 1 to be size_t gets ULONGEST: (baseclass)->length
LOC cp-valprint.c:563 (cp-valprint.c:562)
- Function target_read_memory expects arg 3 to be ssize_t gets UINT: (baseclass)->length
+ Function target_read_memory expects arg 3 to be ssize_t gets ULONGEST: (baseclass)->length
LOC cris-tdep.c:683
- Function xmalloc expects arg 1 to be size_t gets int: len
+ Function xmalloc expects arg 1 to be size_t gets LONGEST: len
LOC cris-tdep.c:684 (cris-tdep.c:685)
+ Assignment of LONGEST to int: si->len = len
+LOC cris-tdep.c:685
Implicitly only storage si->prev (type struct stack_item *) not released before assignment: si->prev = prev
LOC cris-tdep.c:686
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
cris-tdep.c: (in function cris_frame_unwind_cache)
LOC cris-tdep.c:899
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
+LOC cris-tdep.c:1670
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
LOC cris-tdep.c:1678 (cris-tdep.c:1682)
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len - 4
+LOC cris-tdep.c:1682
New fresh storage (type char *) passed as implicitly temp (not released): gettext("cris_store_return_value: type length too large.")
LOC cris-tdep.c:1842 (cris-tdep.c:1847)
+ Function store_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC cris-tdep.c:1847
Passed storage &val not completely defined: regcache_cooked_read_unsigned (..., &val)
LOC cris-tdep.c:1850 (cris-tdep.c:1853)
+ Function store_unsigned_integer expects arg 2 to be int gets LONGEST: len - 4
+LOC cris-tdep.c:1853
New fresh storage (type char *) passed as implicitly temp (not released): gettext("cris_extract_return_value: type length too large")
LOC doublest.c:794
- Operands of == have incompatible types (int, UINT): len * 8 == gdbarch_long_double_format(gdbarch)[0]->totalsize
+ Operands of == have incompatible types (LONGEST, UINT): len * 8 == gdbarch_long_double_format(gdbarch)[0]->totalsize
LOC doublest.c:857
- Function memset expects arg 3 to be size_t gets UINT: (type)->length
+ Function memset expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC doublest.c:883
- Function memset expects arg 3 to be size_t gets UINT: (to_type)->length
+ Function memset expects arg 3 to be size_t gets ULONGEST: (to_type)->length
LOC doublest.c:893
- Function memset expects arg 3 to be size_t gets UINT: (to_type)->length
+ Function memset expects arg 3 to be size_t gets ULONGEST: (to_type)->length
LOC doublest.c:894
- Function memcpy expects arg 3 to be size_t gets UINT: (((from_type)->length) < ((to_type)->length) ? ((from_type)->length) : ((to_type)->length))
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (((from_type)->length) < ((to_type)->length) ? ((from_type)->length) : ((to_type)->length))
LOC dwarf2loc.c:1279
- Function memcpy expects arg 3 to be size_t gets UINT: (checked_type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (checked_type)->length
LOC dwarf2loc.c:1496 (dwarf2loc.c:1503)
+ Assignment of ULONGEST to UINT: source_offset_bits = source_offset % 8
+LOC dwarf2loc.c:1498
+ Assignment of ULONGEST to UINT: dest_avail = 8 - dest_offset_bits % 8
+LOC dwarf2loc.c:1501
+ Operands of < have incompatible types (UINT, ULONGEST): dest_avail < bit_count
+LOC dwarf2loc.c:1503
Function extract_bits expects arg 3 to be int gets UINT: dest_avail
LOC dwarf2loc.c:1505
+ Function insert_bits expects arg 3 to be UINT gets ULONGEST: dest_offset_bits
+LOC dwarf2loc.c:1505
Function insert_bits expects arg 4 to be int gets UINT: dest_avail
LOC dwarf2loc.c:1524
- Function extract_bits expects arg 3 to be int gets UINT: bit_count
+ Function extract_bits expects arg 3 to be int gets ULONGEST: bit_count
LOC dwarf2loc.c:1526
- Function insert_bits expects arg 4 to be int gets UINT: bit_count
+ Function insert_bits expects arg 3 to be UINT gets ULONGEST: dest_offset_bits
+LOC dwarf2loc.c:1526
+ Function insert_bits expects arg 4 to be int gets ULONGEST: bit_count
dwarf2loc.c: (in function read_pieced_value)
LOC dwarf2loc.c:1559
- Assignment of int to size_t: type_len = value_bitsize(v)
-LOC dwarf2loc.c:1562
- Assignment of UINT to size_t: type_len = 8 * (value_type(v))->length
+ Assignment of int to ULONGEST: type_len = value_bitsize(v)
LOC dwarf2loc.c:1584 (dwarf2loc.c:1573)
- Assignment of ULONGEST to size_t: this_size_bits = p->size
+ Assignment of ULONGEST to LONGEST: source_offset_bits = bits_to_skip
LOC dwarf2loc.c:1596 (dwarf2loc.c:1574)
- Operands of >= have incompatible types (ULONGEST, size_t): bits_to_skip >= this_size_bits
+ Operands of < have incompatible types (size_t, ULONGEST): buffer_size < this_size
LOC dwarf2loc.c:1598 (dwarf2loc.c:1584)
- Assignment of ULONGEST to LONGEST: source_offset_bits = bits_to_skip
+ Assignment of ULONGEST to size_t: buffer_size = this_size
LOC dwarf2loc.c:1613
- Operands of < have incompatible types (size_t, int): this_size < register_size(arch, gdb_regnum)
+ Operands of < have incompatible types (ULONGEST, int): this_size < register_size(arch, gdb_regnum)
LOC dwarf2loc.c:1616
- Assignment of arbitrary UINTegral type to int: reg_offset = register_size(arch, gdb_regnum) - this_size
+ Assignment of ULONGEST to int: reg_offset = register_size(arch, gdb_regnum) - this_size
LOC dwarf2loc.c:1627
- Function get_frame_register_bytes expects arg 4 to be int gets size_t: this_size
+ Function get_frame_register_bytes expects arg 4 to be int gets ULONGEST: this_size
LOC dwarf2loc.c:1631 (dwarf2loc.c:1633)
+ Function memset expects arg 3 to be size_t gets ULONGEST: this_size
+LOC dwarf2loc.c:1633
Test expression for if not boolean, type int: optim
LOC dwarf2loc.c:1636
- Function mark_value_bytes_unavailable expects arg 2 to be int gets LONGEST: offset
-LOC dwarf2loc.c:1636
- Function mark_value_bytes_unavailable expects arg 3 to be int gets size_t: this_size
+ Function mark_value_bytes_unavailable expects arg 3 to be LONGEST gets ULONGEST: this_size
LOC dwarf2loc.c:1651
+ Function read_value_memory expects arg 6 to be size_t gets ULONGEST: this_size
+LOC dwarf2loc.c:1651
Null storage buffer passed as non-null param: read_value_memory (..., buffer, ...)
LOC dwarf2loc.c:1656 (dwarf2loc.c:1658)
+ Variable n initialized to type ULONGEST, expects size_t: this_size
+LOC dwarf2loc.c:1658
Operands of > have incompatible types (size_t, LONGEST): n > c->addr_size - source_offset
LOC dwarf2loc.c:1677 (dwarf2loc.c:1679)
+ Variable n initialized to type ULONGEST, expects size_t: this_size
+LOC dwarf2loc.c:1679
Operands of > have incompatible types (size_t, ULONGEST): n > p->v.literal.length - source_offset
LOC dwarf2loc.c:1704
- Function copy_bitwise expects arg 4 to be UINT gets LONGEST: source_offset_bits % 8
-LOC dwarf2loc.c:1705
- Function copy_bitwise expects arg 5 to be UINT gets size_t: this_size_bits
+ Function copy_bitwise expects arg 4 to be ULONGEST gets LONGEST: source_offset_bits % 8
LOC dwarf2loc.c:1743
- Assignment of int to size_t: type_len = value_bitsize(to)
-LOC dwarf2loc.c:1746
- Assignment of UINT to size_t: type_len = 8 * (value_type(to))->length
+ Assignment of int to ULONGEST: type_len = value_bitsize(to)
LOC dwarf2loc.c:1766 (dwarf2loc.c:1756)
- Assignment of ULONGEST to size_t: this_size_bits = p->size
+ Assignment of ULONGEST to LONGEST: dest_offset_bits = bits_to_skip
LOC dwarf2loc.c:1787 (dwarf2loc.c:1757)
- Operands of >= have incompatible types (ULONGEST, size_t): bits_to_skip >= this_size_bits
+ Operands of < have incompatible types (size_t, ULONGEST): buffer_size < this_size
LOC dwarf2loc.c:1789 (dwarf2loc.c:1766)
- Assignment of ULONGEST to LONGEST: dest_offset_bits = bits_to_skip
+ Assignment of ULONGEST to size_t: buffer_size = this_size
LOC dwarf2loc.c:1805
- Operands of <= have incompatible types (size_t, int): this_size <= register_size(arch, gdb_regnum)
+ Operands of <= have incompatible types (ULONGEST, int): this_size <= register_size(arch, gdb_regnum)
LOC dwarf2loc.c:1807
- Assignment of arbitrary UINTegral type to int: reg_offset = register_size(arch, gdb_regnum) - this_size
+ Assignment of ULONGEST to int: reg_offset = register_size(arch, gdb_regnum) - this_size
LOC dwarf2loc.c:1816
- Function get_frame_register_bytes expects arg 4 to be int gets size_t: this_size
+ Function get_frame_register_bytes expects arg 4 to be int gets ULONGEST: this_size
LOC dwarf2loc.c:1829
- Function copy_bitwise expects arg 2 to be UINT gets LONGEST: dest_offset_bits
-LOC dwarf2loc.c:1830
- Function copy_bitwise expects arg 4 to be UINT gets LONGEST: source_offset_bits
+ Function copy_bitwise expects arg 2 to be ULONGEST gets LONGEST: dest_offset_bits
LOC dwarf2loc.c:1830 (dwarf2loc.c:1831)
- Function copy_bitwise expects arg 5 to be UINT gets size_t: this_size_bits
+ Function copy_bitwise expects arg 4 to be ULONGEST gets LONGEST: source_offset_bits
LOC dwarf2loc.c:1836
- Function put_frame_register_bytes expects arg 4 to be int gets size_t: this_size
+ Function put_frame_register_bytes expects arg 4 to be int gets ULONGEST: this_size
LOC dwarf2loc.c:1853
- Function copy_bitwise expects arg 2 to be UINT gets LONGEST: dest_offset_bits
-LOC dwarf2loc.c:1854
- Function copy_bitwise expects arg 4 to be UINT gets LONGEST: source_offset_bits
+ Function copy_bitwise expects arg 2 to be ULONGEST gets LONGEST: dest_offset_bits
LOC dwarf2loc.c:1854 (dwarf2loc.c:1855)
- Function copy_bitwise expects arg 5 to be UINT gets size_t: this_size_bits
+ Function copy_bitwise expects arg 4 to be ULONGEST gets LONGEST: source_offset_bits
LOC dwarf2loc.c:1860
- Function write_memory expects arg 3 to be ssize_t gets size_t: this_size
+ Function write_memory expects arg 3 to be ssize_t gets ULONGEST: this_size
LOC dwarf2loc.c:1902
- Operands of >= have incompatible types (int, size_t): bit_offset >= this_size_bits
+ Operands of >= have incompatible types (LONGEST, size_t): bit_offset >= this_size_bits
dwarf2loc.c: (in function indirect_pieced_value)
LOC dwarf2loc.c:2002 (dwarf2loc.c:2001)
- Operands of >= have incompatible types (int, size_t): bit_offset >= this_size_bits
+ Operands of >= have incompatible types (LONGEST, size_t): bit_offset >= this_size_bits
LOC dwarf2loc.c:2190 (dwarf2loc.c:2188)
- Function set_value_offset expects arg 2 to be int gets LONGEST: byte_offset
-LOC dwarf2loc.c:2189
Fresh storage c not released before scope exit
LOC dwarf2loc.c:2233 (dwarf2loc.c:2230)
- Variable n initialized to type UINT, expects size_t: (value_type(value))->length
-LOC dwarf2loc.c:2232
- Operands of > have incompatible types (LONGEST, size_t): byte_offset + (type)->length > n
+ Operands of > have incompatible types (LONGEST, ULONGEST): byte_offset + (type)->length > n
LOC dwarf2loc.c:2256 (dwarf2loc.c:2248)
- Operands of > have incompatible types (size_t, UINT): n > (type)->length
-LOC dwarf2loc.c:2254
- Assignment of UINT to size_t: n = (type)->length
-LOC dwarf2loc.c:2255
Fresh storage objfile_gdbarch not released before scope exit
LOC dwarf2loc.c:2257
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: n
+LOC dwarf2loc.c:2258
Fresh storage value not released before scope exit
LOC dwarf2loc.c:2277 (dwarf2loc.c:2276)
- Operands of > have incompatible types (size_t, UINT): n > (type)->length
+ Operands of > have incompatible types (size_t, ULONGEST): n > (type)->length
LOC dwarf2loc.c:2283 (dwarf2loc.c:2282)
- Assignment of UINT to size_t: n = (type)->length
+ Assignment of ULONGEST to size_t: n = (type)->length
dwarf2read.c: (in function dwarf2_section_buffer_overflow_complaint)
LOC dwarf2read.c:6117
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC dwarf2read.c:7763 (dwarf2read.c:7764)
+ Assignment of size_t to ULONGEST: dlbaton->size = ((attr)->u.blk)->size
+LOC dwarf2read.c:7764
Implicitly only storage dlbaton->per_cu (type struct dwarf2_per_cu_data *) not released before assignment: dlbaton->per_cu = cu->per_cu
LOC dwarf2read.c:7885 (dwarf2read.c:7882)
- Assignment of UINT to size_t: parameter->value_size = ((attr)->u.blk)->size
-LOC dwarf2read.c:7885
Implicitly only storage parameter->data_value (type gdb_byte *) not released before assignment: parameter->data_value = NULL
LOC dwarf2read.c:7903 (dwarf2read.c:7900)
- Assignment of UINT to size_t: parameter->data_value_size = ((attr)->u.blk)->size
-LOC dwarf2read.c:7903
Fresh storage loc not released before scope exit
LOC dwarf2read.c:8525 (dwarf2read.c:8524)
- Assignment of LONGEST to int: ((*fp).loc.bitpos) = (offset * bits_per_byte)
-LOC dwarf2read.c:8525
Fresh storage attr (type struct attribute *) not released before assignment: attr = dwarf2_attr(die, DW_AT_bit_offset, cu)
LOC dwarf2read.c:8546 (dwarf2read.c:8535)
- Assignment of ULONGEST to int: ((*fp).loc.bitpos) = ((((*fp).loc.bitpos) + 0) + ((attr)->u.unsnd))
-LOC dwarf2read.c:8546
Variable bit_offset initialized to type ULONGEST, expects int: ((attr)->u.unsnd)
LOC dwarf2read.c:8635 (dwarf2read.c:8633)
- Assignment of LONGEST to int: ((*fp).loc.bitpos) = (offset * bits_per_byte)
-LOC dwarf2read.c:8635
Implicitly only storage fp->type (type struct type *) not released before assignment: ((*fp).type) = die_type(die, cu)
LOC dwarf2read.c:9184 (dwarf2read.c:9177)
- Assignment of ULONGEST to UINT: (type)->length = ((attr)->u.unsnd)
-LOC dwarf2read.c:9184
Test expression for if not boolean, type int: producer_is_icc(cu)
LOC dwarf2read.c:9472 (dwarf2read.c:9460)
- Assignment of ULONGEST to UINT: (type)->length = ((attr)->u.unsnd)
-LOC dwarf2read.c:9472
Test expression for if not boolean, type int: die_is_declaration(die, cu)
LOC dwarf2read.c:9685 (dwarf2read.c:9682)
- Assignment of ULONGEST to UINT: (type)->length = ((attr)->u.unsnd)
-LOC dwarf2read.c:9685
New fresh storage (type char *) passed as implicitly temp (not released): gettext("DW_AT_byte_size for array type smaller "
"than the total size of elements")
LOC dwarf2read.c:9758 (dwarf2read.c:9756)
- Assignment of ULONGEST to UINT: (set_type)->length = ((attr)->u.unsnd)
-LOC dwarf2read.c:9758
Fresh storage domain_type not released before return
LOC dwarf2read.c:9997
- Operands of != have incompatible types (UINT, int): (type)->length != byte_size
+ Operands of != have incompatible types (ULONGEST, int): (type)->length != byte_size
LOC dwarf2read.c:10009
- Operands of != have incompatible types (UINT, int): (type)->length != byte_size
+ Operands of != have incompatible types (ULONGEST, int): (type)->length != byte_size
LOC dwarf2read.c:10075 (dwarf2read.c:10071)
- Assignment of ULONGEST to UINT: (type)->length = ((attr)->u.unsnd)
-LOC dwarf2read.c:10075
- Assignment of unsigned char to UINT: (type)->length = cu_header->addr_size
+ Assignment of unsigned char to ULONGEST: (type)->length = cu_header->addr_size
LOC dwarf2read.c:10587
- Operands of >= have incompatible types (UINT, int): (int_type)->length >= addr_size
+ Operands of >= have incompatible types (ULONGEST, int): (int_type)->length >= addr_size
LOC dwarf2read.c:10592
- Operands of >= have incompatible types (UINT, int): (int_type)->length >= addr_size
+ Operands of >= have incompatible types (ULONGEST, int): (int_type)->length >= addr_size
LOC dwarf2read.c:10597
- Operands of >= have incompatible types (UINT, int): (int_type)->length >= addr_size
+ Operands of >= have incompatible types (ULONGEST, int): (int_type)->length >= addr_size
LOC dwarf2read.c:10630 (dwarf2read.c:10628)
- Assignment of ULONGEST to UINT: (range_type)->length = ((attr)->u.unsnd)
-LOC dwarf2read.c:10630
Return value (type struct type *) ignored: set_die_type(die...
LOC dwarf2read.c:11686 (dwarf2read.c:11688)
+ Assignment of UINT to size_t: blk->size = read_2_bytes(abfd, info_ptr)
+LOC dwarf2read.c:11688
+ Function read_n_bytes expects arg 3 to be UINT gets size_t: blk->size
+LOC dwarf2read.c:11688
Implicitly only storage blk->data (type gdb_byte *) not released before assignment: blk->data = read_n_bytes(abfd, info_ptr, blk->size)
LOC dwarf2read.c:11694 (dwarf2read.c:11696)
+ Assignment of UINT to size_t: blk->size = read_4_bytes(abfd, info_ptr)
+LOC dwarf2read.c:11696
+ Function read_n_bytes expects arg 3 to be UINT gets size_t: blk->size
+LOC dwarf2read.c:11696
Implicitly only storage blk->data (type gdb_byte *) not released before assignment: blk->data = read_n_bytes(abfd, info_ptr, blk->size)
LOC dwarf2read.c:11730
- Assignment of ULONGEST to UINT: blk->size = read_unsigned_leb128(abfd, info_ptr, &bytes_read)
+ Assignment of ULONGEST to size_t: blk->size = read_unsigned_leb128(abfd, info_ptr, &bytes_read)
+LOC dwarf2read.c:11732
+ Function read_n_bytes expects arg 3 to be UINT gets size_t: blk->size
LOC dwarf2read.c:11738 (dwarf2read.c:11740)
+ Assignment of UINT to size_t: blk->size = read_1_byte(abfd, info_ptr)
+LOC dwarf2read.c:11740
+ Function read_n_bytes expects arg 3 to be UINT gets size_t: blk->size
+LOC dwarf2read.c:11740
Implicitly only storage blk->data (type gdb_byte *) not released before assignment: blk->data = read_n_bytes(abfd, info_ptr, blk->size)
LOC dwarf2read.c:13295
- Operands of == have incompatible types (UINT, int): ((attr)->u.blk)->size == 1 + leb128_size(&((attr)->u.blk)->data[1])
+ Operands of == have incompatible types (size_t, int): ((attr)->u.blk)->size == 1 + leb128_size(&((attr)->u.blk)->data[1])
LOC dwarf2read.c:13760
- Operands of != have incompatible types (UINT, unsigned char): (type)->length != cu_header->addr_size
+ Operands of != have incompatible types (ULONGEST, unsigned char): (type)->length != cu_header->addr_size
LOC dwarf2read.c:13762
- Function dwarf2_const_value_length_mismatch_complaint expects arg 2 to be int gets unsigned char: cu_header->addr_size
+ Function dwarf2_const_value_length_mismatch_complaint expects arg 2 to be LONGEST gets unsigned char: cu_header->addr_size
LOC dwarf2read.c:13795 (dwarf2read.c:13796)
- Function dwarf2_const_value_length_mismatch_complaint expects arg 2 to be int gets UINT: blk->size
+ Operands of != have incompatible types (ULONGEST, size_t): (type)->length != blk->size
LOC dwarf2read.c:13796 (dwarf2read.c:13797)
- Function dwarf2_const_value_length_mismatch_complaint expects arg 3 to be int gets UINT: (type)->length
+ Function dwarf2_const_value_length_mismatch_complaint expects arg 2 to be LONGEST gets size_t: blk->size
+LOC dwarf2read.c:13797
+ Function dwarf2_const_value_length_mismatch_complaint expects arg 3 to be LONGEST gets ULONGEST: (type)->length
LOC dwarf2read.c:14734 (dwarf2read.c:14742)
+ Function pulongest expects arg 1 to be ULONGEST gets size_t: ((&die->attrs[i])->u.blk)->size
+LOC dwarf2read.c:14738
+ Function pulongest expects arg 1 to be ULONGEST gets size_t: ((&die->attrs[i])->u.blk)->size
+LOC dwarf2read.c:14742
Function hex_string expects arg 1 to be LONGEST gets ULONGEST: ((&die->attrs[i])->u.unsnd)
LOC dwarf2read.c:15115 (dwarf2read.c:15121)
+ Assignment of size_t to ULONGEST: retval.size = ((attr)->u.blk)->size
+LOC dwarf2read.c:15121
Null storage retval.data returned as non-null: retval
LOC dwarf2read.c:15318
- Variable size initialized to type UINT, expects int: blk->size
+ Variable size initialized to type size_t, expects int: blk->size
LOC dwarf2read.c:16577 (dwarf2read.c:16578)
+ Assignment of size_t to ULONGEST: baton->size = ((attr)->u.blk)->size
+LOC dwarf2read.c:16578
Implicitly only storage baton->data (type gdb_byte *) not released before assignment: baton->data = ((attr)->u.blk)->data
LOC eval.c:446 (eval.c:445)
- Function memcpy expects arg 3 to be size_t gets UINT: (value_type(val))->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (value_type(val))->length
LOC eval.c:489 (eval.c:488)
- Function memcpy expects arg 3 to be size_t gets int: element_size
+ Function memcpy expects arg 3 to be size_t gets LONGEST: element_size
LOC eval.c:498 (eval.c:497)
- Function memcpy expects arg 3 to be size_t gets int: element_size
+ Function memcpy expects arg 3 to be size_t gets LONGEST: element_size
LOC eval.c:611 (eval.c:610)
- Operands of > have incompatible types (UINT, int): (type1)->length * 8 > gdbarch_double_bit(gdbarch)
+ Operands of > have incompatible types (ULONGEST, int): (type1)->length * 8 > gdbarch_double_bit(gdbarch)
LOC eval.c:612 (eval.c:611)
- Operands of > have incompatible types (UINT, int): (type2)->length * 8 > gdbarch_double_bit(gdbarch)
+ Operands of > have incompatible types (ULONGEST, int): (type2)->length * 8 > gdbarch_double_bit(gdbarch)
LOC eval.c:715 (eval.c:714)
- Operands of > have incompatible types (UINT, int): result_len > gdbarch_long_bit(gdbarch) / 8
+ Operands of > have incompatible types (ULONGEST, int): result_len > gdbarch_long_bit(gdbarch) / 8
LOC eval.c:722 (eval.c:721)
- Operands of > have incompatible types (UINT, int): result_len > gdbarch_long_bit(gdbarch) / 8
+ Operands of > have incompatible types (ULONGEST, int): result_len > gdbarch_long_bit(gdbarch) / 8
LOC eval.c:979 (eval.c:978)
- Function memset expects arg 3 to be size_t gets UINT: (type)->length
+ Function memset expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC eval.c:998 (eval.c:997)
- Function memset expects arg 3 to be size_t gets UINT: (expect_type)->length
+ Function memset expects arg 3 to be size_t gets ULONGEST: (expect_type)->length
LOC eval.c:1029 (eval.c:1028)
- Function memcpy expects arg 3 to be size_t gets int: element_size
+ Function memcpy expects arg 3 to be size_t gets LONGEST: element_size
LOC eval.c:1052 (eval.c:1051)
- Function memset expects arg 3 to be size_t gets UINT: (type)->length
+ Function memset expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC findcmd.c:182
- Operands of > have incompatible types (int, size_t): (val_bytes) > (sizeof(int64_t))
+ Operands of > have incompatible types (LONGEST, size_t): (val_bytes) > (sizeof(int64_t))
LOC findcmd.c:182
- Conditional clauses are not of same type: (val_bytes) (int), (sizeof(int64_t)) (size_t)
+ Conditional clauses are not of same type: (val_bytes) (LONGEST), (sizeof(int64_t)) (size_t)
LOC findcmd.c:216
- Function memcpy expects arg 3 to be size_t gets int: val_bytes
+ Function memcpy expects arg 3 to be size_t gets LONGEST: val_bytes
findvar.c: (in function signed_pointer_to_address)
findvar.c: (in function address_to_signed_pointer)
LOC findvar.c:468
+ Function store_signed_integer expects arg 2 to be int gets LONGEST: len
+LOC findvar.c:468
New fresh storage (type gdb_byte *) passed as implicitly temp (not released): value_contents_raw(v)
LOC findvar.c:493
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC frv-tdep.c:1129 (frv-tdep.c:1135)
+ Function store_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC frv-tdep.c:1135
Passed storage &regval not completely defined: regcache_cooked_read_unsigned (..., &regval)
LOC frv-tdep.c:1282 (frv-tdep.c:1286)
+ Variable partial_len initialized to type LONGEST, expects int: (len < 4 ? len : 4)
+LOC frv-tdep.c:1286
Function extract_unsigned_integer expects arg 1 to be gdb_byte * gets char *: val
LOC frv-tdep.c:1337
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
frv-tdep.c: (in function frv_return_value)
LOC f-valprint.c:85
Return value type LONGEST does not match declared type int: ((((((type))->main_type->flds_bnds.fields[0]).type))->main_type->flds_bnds.bounds->high)
-f-valprint.c: (in function f77_get_dynamic_length_of_aggregate)
-LOC f-valprint.c:115
- Assignment of int to UINT: (type)->length = (upper_bound - lower_bound + 1) * (check_typedef((type)->main_type->target_type))->length
f-valprint.c: (in function f77_create_arrayprint_offset_tbl)
LOC f-valprint.c:178
+ Operands of < have incompatible types (int, LONGEST): i < (f77_array_offset_tbl[nss][1])
+LOC f-valprint.c:178
Operands of < have incompatible types (int, UINT): (*elts) < options->print_max
LOC f-valprint.c:189 (f-valprint.c:194)
+ Operands of < have incompatible types (int, LONGEST): i < (f77_array_offset_tbl[nss][1])
+LOC f-valprint.c:194
+ Operands of < have incompatible types (int, LONGEST): i < (f77_array_offset_tbl[nss][1])
+LOC f-valprint.c:194
Operands of < have incompatible types (int, UINT): (*elts) < options->print_max
LOC f-valprint.c:203 (f-valprint.c:206)
+ Operands of != have incompatible types (int, LONGEST): i != ((f77_array_offset_tbl[nss][1]) - 1)
+LOC f-valprint.c:206
Operands of == have incompatible types (int, UINT): *elts == options->print_max - 1
+LOC f-valprint.c:207
+ Operands of != have incompatible types (int, LONGEST): i != ((f77_array_offset_tbl[nss][1]) - 1)
f-valprint.c: (in function f77_print_array)
LOC gdbtypes.c:804
- Operands of > have incompatible types (UINT, size_t): (type)->length > sizeof(LONGEST)
+ Operands of > have incompatible types (ULONGEST, size_t): (type)->length > sizeof(LONGEST)
LOC gdbtypes.c:906 (gdbtypes.c:902)
- Assignment of LONGEST to UINT: (result_type)->length = (element_type)->length * (high_bound - low_bound + 1)
-LOC gdbtypes.c:906
Test expression for conditional not boolean, type UINT: ((result_type)->main_type->flag_objfile_owned)
gdbtypes.c: (in function smash_to_methodptr_type)
LOC gdbtypes.c:1653 (gdbtypes.c:1645)
- Assignment of ULONGEST to UINT: (type)->length = len
-LOC gdbtypes.c:1653
Fresh storage target_type not released before scope exit
LOC gdbtypes.c:3681 (gdbtypes.c:3683)
+ Assignment of LONGEST to int: left = (((f[0]).loc.bitpos) + 0) % alignment
+LOC gdbtypes.c:3683
Test expression for if not boolean, type int: left
LOC gnu-v2-abi.c:168 (gnu-v2-abi.c:165)
- Function set_value_offset expects arg 2 to be int gets LONGEST: value_offset(arg1) + value_as_long(value_field(entry, 0))
-LOC gnu-v2-abi.c:168
Operand of ! is non-boolean (int): !value_lazy(arg1)
LOC gnu-v2-abi.c:272 (gnu-v2-abi.c:271)
- Left operand of && is non-boolean (int *): top && ((*top) > 0)
+ Left operand of && is non-boolean (LONGEST *): top && ((*top) > 0)
LOC gnu-v2-abi.c:382 (gnu-v2-abi.c:381)
- Return value type ULONGEST does not match declared type int: addr - (LONGEST)address + embedded_offset
+ Return value type ULONGEST does not match declared type LONGEST: addr - (LONGEST)address + embedded_offset
LOC gnu-v3-abi.c:346 (gnu-v3-abi.c:345)
- Assignment of LONGEST to int: *top_p = -offset_to_top
-LOC gnu-v3-abi.c:346
Fresh storage gdbarch not released before return
LOC gnu-v3-abi.c:456
- Return value type LONGEST does not match declared type int: base_offset
-LOC gnu-v3-abi.c:456
Fresh storage gdbarch not released before return
LOC gnu-v3-abi.c:645
- Return value type UINT does not match declared type int: 2 * (builtin_type(gdbarch)->builtin_data_ptr)->length
+ Return value type ULONGEST does not match declared type int: 2 * (builtin_type(gdbarch)->builtin_data_ptr)->length
LOC gnu-v3-abi.c:655
- Variable size initialized to type UINT, expects int: (builtin_type(gdbarch)->builtin_data_ptr)->length
+ Variable size initialized to type ULONGEST, expects int: (builtin_type(gdbarch)->builtin_data_ptr)->length
LOC go-valprint.c:107 (go-valprint.c:109)
+ Function print_go_string expects arg 3 to be int gets LONGEST: embedded_offset
+LOC go-valprint.c:109
Fresh storage type not released before return
LOC h8300-tdep.c:675
- Function C_alloca expects arg 1 to be size_t gets int: padded_len
+ Function C_alloca expects arg 1 to be size_t gets LONGEST: padded_len
LOC h8300-tdep.c:677
- Function memset expects arg 3 to be size_t gets int: padded_len
+ Function memset expects arg 3 to be size_t gets LONGEST: padded_len
LOC h8300-tdep.c:679
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC h8300-tdep.c:686
- Right operand of && is non-boolean (int): len > wordsize && len % wordsize
+ Right operand of && is non-boolean (LONGEST): len > wordsize && len % wordsize
LOC h8300-tdep.c:689
- Function write_memory expects arg 3 to be ssize_t gets int: padded_len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: padded_len
LOC h8300-tdep.c:716
- Function write_memory expects arg 3 to be ssize_t gets int: padded_len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: padded_len
LOC h8300-tdep.c:747
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC h8300-tdep.c:784
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC h8300-tdep.c:851
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC h8300-tdep.c:881
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC h8300-tdep.c:928
- Function read_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function read_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC hppa-tdep.c:740
- Function write_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function write_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC hppa-tdep.c:766
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC hppa-tdep.c:867
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC hppa-tdep.c:889
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC hppa-tdep.c:1026
+ Function regcache_cooked_write_part expects arg 4 to be int gets LONGEST: len
+LOC hppa-tdep.c:1026
New fresh storage (type gdb_byte *) passed as implicitly temp (not released): value_contents(arg)
LOC hppa-tdep.c:1062
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
+LOC hppa-tdep.c:1068
+ Function regcache_cooked_write_part expects arg 4 to be int gets LONGEST: ((len) < (8) ? (len) : (8))
LOC hppa-tdep.c:1126
- Variable part initialized to type UINT, expects int: (type)->length % 4
+ Variable part initialized to type ULONGEST, expects int: (type)->length % 4
LOC hppa-tdep.c:1141
- Operands of < have incompatible types (int, UINT): b < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): b < (type)->length
LOC hppa-tdep.c:1181 (hppa-tdep.c:1183)
+ Assignment of LONGEST to int: offset = 8 - len
+LOC hppa-tdep.c:1183
Test expression for if not boolean, type int: hppa64_floating_p(type)
LOC hppa-tdep.c:1203 (hppa-tdep.c:1224)
+ Assignment of LONGEST to int: offset = 8 - len
+LOC hppa-tdep.c:1225
+ Function regcache_cooked_read_part expects arg 4 to be int gets LONGEST: ((len) < (8) ? (len) : (8))
+LOC hppa-tdep.c:1224
Return value (type enum register_status) ignored: regcache_cooked_...
LOC hppa-tdep.c:1237 (hppa-tdep.c:1156)
+ Function regcache_cooked_write_part expects arg 4 to be int gets LONGEST: ((len) < (8) ? (len) : (8))
+LOC hppa-tdep.c:1156
Parameter gdbarch not used
LOC i386-darwin-tdep.c:132
- Return value type UINT does not match declared type int: (type)->length
+ Return value type ULONGEST does not match declared type LONGEST: (type)->length
LOC i386-darwin-tdep.c:202
- Assignment of ULONGEST to int: args_space = align_up(args_space, align)
+ Function align_up expects arg 2 to be int gets LONGEST: align
+LOC i386-darwin-tdep.c:202
+ Assignment of ULONGEST to LONGEST: args_space = align_up(args_space, align)
LOC i386-darwin-tdep.c:205
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC i386-nat.c:325
- Operands of || are non-booleans (CORE_ADDR, int): addr || len
+ Operands of || are non-booleans (CORE_ADDR, LONGEST): addr || len
i386-nat.c: (in function i386_length_and_rw_bits)
LOC i386-nat.c:531 (i386-nat.c:553)
+ Conditional clauses are not of same type: (max_wp_len - 1) (int), len - 1 (LONGEST)
+LOC i386-nat.c:553
New fresh storage (type char *) passed as implicitly temp (not released): gettext("Invalid value %d of operation in i386_handle_nonaligned_watchpoint.\n")
LOC i386-nat.c:613 (i386-nat.c:622)
+ Function i386_length_and_rw_bits expects arg 1 to be int gets LONGEST: len
+LOC i386-nat.c:622
Test expression for if not boolean, type int: maint_show_dr
LOC i386-nat.c:647 (i386-nat.c:656)
+ Function i386_length_and_rw_bits expects arg 1 to be int gets LONGEST: len
+LOC i386-nat.c:656
Test expression for if not boolean, type int: maint_show_dr
LOC i386-tdep.c:2378
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC i386-tdep.c:2454
- Function memset expects arg 3 to be size_t gets int: len
+ Function memset expects arg 3 to be size_t gets LONGEST: len
LOC i386-tdep.c:2473
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC i386-tdep.c:2480
- Function memcpy expects arg 3 to be size_t gets int: len - low_size
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len - low_size
LOC i386-tdep.c:2540 (i386-tdep.c:2549)
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("Cannot store return value of %d bytes long.")
+ Function regcache_raw_write_part expects arg 4 to be int gets LONGEST: len
+LOC i386-tdep.c:2545
+ Function regcache_raw_write_part expects arg 4 to be int gets LONGEST: len - low_size
+LOC i386-tdep.c:2549
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("Cannot store return value of %s bytes long.")
LOC i386-tdep.c:2578 (i386-tdep.c:2577)
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC i386-tdep.c:2643 (i386-tdep.c:2642)
- Function read_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function read_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC i386-tdep.c:3030 (i386-tdep.c:3029)
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
i386-tdep.c: (in function i386_register_to_value)
LOC i386-tdep.c:3063 (i386-tdep.c:3062)
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC i386-tdep.c:3099 (i386-tdep.c:3098)
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC ia64-tdep.c:3234
- Variable n initialized to type UINT, expects int: (type)->length / (float_elt_type)->length
+ Variable n initialized to type ULONGEST, expects int: (type)->length / (float_elt_type)->length
LOC ia64-tdep.c:3265
- Variable reglen initialized to type UINT, expects int: (register_type(gdbarch, (0 + 8)))->length
+ Variable reglen initialized to type ULONGEST, expects int: (register_type(gdbarch, (0 + 8)))->length
LOC ia64-tdep.c:3267
- Variable m initialized to type UINT, expects int: (type)->length % reglen
+ Variable m initialized to type ULONGEST, expects int: (type)->length % reglen
LOC ia64-tdep.c:3299
- Variable n initialized to type UINT, expects int: (type)->length / (float_elt_type)->length
+ Variable n initialized to type ULONGEST, expects int: (type)->length / (float_elt_type)->length
LOC ia64-tdep.c:3315
- Variable reglen initialized to type UINT, expects int: (register_type(gdbarch, (0 + 8)))->length
+ Variable reglen initialized to type ULONGEST, expects int: (register_type(gdbarch, (0 + 8)))->length
LOC ia64-tdep.c:3317
- Variable m initialized to type UINT, expects int: (type)->length % reglen
+ Variable m initialized to type ULONGEST, expects int: (type)->length % reglen
LOC ia64-tdep.c:3740 (ia64-tdep.c:3738)
- Operands of && are non-boolean (int): (nslots & 1) && slot_alignment_is_next_even(type)
+ Operands of && are non-booleans (LONGEST, int): (nslots & 1) && slot_alignment_is_next_even(type)
LOC ia64-tdep.c:3822 (ia64-tdep.c:3820)
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC ia64-tdep.c:3822
New fresh storage (type gdb_byte *) passed as implicitly temp (not released): value_contents(arg)
LOC infcall.c:1018
- Function read_value_memory expects arg 6 to be size_t gets UINT: (values_type)->length
+ Function read_value_memory expects arg 6 to be size_t gets ULONGEST: (values_type)->length
LOC infcall.c:1035
- Function read_value_memory expects arg 6 to be size_t gets UINT: (values_type)->length
+ Function read_value_memory expects arg 6 to be size_t gets ULONGEST: (values_type)->length
LOC infrun.c:6672 (infrun.c:6669)
- Variable len initialized to type UINT, expects size_t: (type)->length
+ Function xmalloc expects arg 1 to be size_t gets ULONGEST: len
LOC infrun.c:6733 (infrun.c:6730)
- Variable len initialized to type UINT, expects size_t: (type)->length
-LOC infrun.c:6734
- Function target_write expects arg 6 to be LONGEST gets size_t: len
+ Function target_write expects arg 6 to be LONGEST gets ULONGEST: (type)->length
iq2000-tdep.c: (in function iq2000_register_name)
+LOC iq2000-tdep.c:513
+ Variable size initialized to type LONGEST, expects int: len % 4 ? : 4
+LOC iq2000-tdep.c:564
+ Test expression for conditional not boolean, type LONGEST: len % 4
LOC iq2000-tdep.c:564
- Test expression for conditional not boolean, type int: len % 4
+ Variable size initialized to type LONGEST, expects int: len % 4 ? : 4
LOC iq2000-tdep.c:581
- Function read_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function read_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
+LOC iq2000-tdep.c:739
+ Assignment of LONGEST to int: slacklen = (4 - (typelen % 4)) % 4
LOC iq2000-tdep.c:741 (iq2000-tdep.c:740)
- Function memcpy expects arg 3 to be size_t gets int: typelen
+ Function memcpy expects arg 3 to be size_t gets LONGEST: typelen
LOC iq2000-tdep.c:772 (iq2000-tdep.c:771)
- Function write_memory expects arg 3 to be ssize_t gets int: typelen
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: typelen
LOC iq2000-tdep.c:782 (iq2000-tdep.c:781)
- Function write_memory expects arg 3 to be ssize_t gets int: typelen
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: typelen
LOC jv-lang.c:469 (jv-lang.c:467)
- Assignment of LONGEST to int: boffset = value_as_long(value_struct_elt(&temp, NULL, "boffset", NULL, "structure"))
-LOC jv-lang.c:469
Test expression for if not boolean, type int: accflags & 0x0001
LOC jv-lang.c:482
- Assignment of int to CORE_ADDR: (((type)->main_type->flds_bnds.fields[i]).loc.physaddr) = (boffset)
+ Assignment of LONGEST to CORE_ADDR: (((type)->main_type->flds_bnds.fields[i]).loc.physaddr) = (boffset)
LOC jv-lang.c:611
- Return value type UINT does not match declared type int: (objtype)->length
+ Return value type ULONGEST does not match declared type int: (objtype)->length
LOC lm32-tdep.c:287 (lm32-tdep.c:295)
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC lm32-tdep.c:295
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC lm32-tdep.c:340
- Function read_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function read_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
+LOC lm32-tdep.c:357
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC lm32-tdep.c:364
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len - 4
LOC m2-lang.c:121 (m2-lang.c:129)
+ Operands of < have incompatible types (UINT, ULONGEST): i < length
+LOC m2-lang.c:129
Test expression for if not boolean, type int: quit_flag
LOC m2-lang.c:139 (m2-lang.c:147)
+ Operands of < have incompatible types (UINT, ULONGEST): rep1 < length
+LOC m2-lang.c:147
Test expression for if not boolean, type int: in_quotes
LOC m2-lang.c:185
+ Operands of < have incompatible types (UINT, ULONGEST): i < length
+LOC m2-lang.c:185
Left operand of || is non-boolean (int): force_ellipses || i < length
LOC m2-typeprint.c:377 (m2-typeprint.c:374)
- Operands of < have incompatible types (UINT, size_t): (type)->length < sizeof(LONGEST)
+ Operands of < have incompatible types (ULONGEST, size_t): (type)->length < sizeof(LONGEST)
LOC m2-typeprint.c:591 (m2-typeprint.c:610)
- Operands of != have incompatible types (int, LONGEST): lastval != ((((type)->main_type->flds_bnds.fields[i]).loc.enumval) + 0)
-LOC m2-typeprint.c:614
- Assignment of LONGEST to int: lastval = ((((type)->main_type->flds_bnds.fields[i]).loc.enumval) + 0)
-LOC m2-typeprint.c:588
Parameter level not used
LOC m2-valprint.c:276 (m2-valprint.c:277)
- Assignment of UINT to int: eltlen = (type)->length
-LOC m2-valprint.c:278
Test expression for if not boolean, type int: options->prettyprint_arrays
LOC m2-valprint.c:319 (m2-valprint.c:320)
- Previous definition of i: UINT
+ Previous definition of i: ULONGEST
LOC m32r-tdep.c:260
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC m32r-tdep.c:744
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC m32r-tdep.c:799 (m32r-tdep.c:805)
+ Function store_unsigned_integer expects arg 2 to be int gets LONGEST: (len > 4 ? len - 4 : len)
+LOC m32r-tdep.c:805
Return value (type enum register_status) ignored: regcache_cooked_...
+LOC m68hc11-tdep.c:1196
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
LOC m68hc11-tdep.c:1222
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
+LOC m68hc11-tdep.c:1275
+ Function regcache_raw_write_part expects arg 3 to be int gets LONGEST: 2 - len
+LOC m68hc11-tdep.c:1275
+ Function regcache_raw_write_part expects arg 4 to be int gets LONGEST: len
+LOC m68hc11-tdep.c:1278
+ Function regcache_raw_write_part expects arg 3 to be int gets LONGEST: 4 - len
+LOC m68hc11-tdep.c:1279
+ Function regcache_raw_write_part expects arg 4 to be int gets LONGEST: len - 2
LOC m68hc11-tdep.c:1294
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC m68k-tdep.c:225
- Function get_frame_register_bytes expects arg 4 to be int gets UINT: (type)->length
+ Function get_frame_register_bytes expects arg 4 to be int gets ULONGEST: (type)->length
LOC m68k-tdep.c:301
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC m68k-tdep.c:306
- Function memcpy expects arg 3 to be size_t gets int: len - 4
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len - 4
m68k-tdep.c: (in function m68k_svr4_extract_return_value)
LOC m68k-tdep.c:323 (m68k-tdep.c:318)
- Variable len initialized to type UINT, expects int: (type)->length
-LOC m68k-tdep.c:323
Left operand of && is non-boolean (int): tdep->float_return && (type)->main_type->code == TYPE_CODE_FLT
LOC m68k-tdep.c:344 (m68k-tdep.c:353)
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("Cannot store return value of %d bytes long.")
-m68k-tdep.c: (in function m68k_svr4_store_return_value)
+ Function regcache_raw_write_part expects arg 3 to be int gets LONGEST: 4 - len
+LOC m68k-tdep.c:344
+ Function regcache_raw_write_part expects arg 4 to be int gets LONGEST: len
+LOC m68k-tdep.c:347
+ Function regcache_raw_write_part expects arg 3 to be int gets LONGEST: 8 - len
LOC m68k-tdep.c:348 (m68k-tdep.c:360)
- Variable len initialized to type UINT, expects int: (type)->length
+ Function regcache_raw_write_part expects arg 4 to be int gets LONGEST: len - 4
+LOC m68k-tdep.c:353
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("Cannot store return value of %s bytes long.")
+m68k-tdep.c: (in function m68k_svr4_store_return_value)
LOC m68k-tdep.c:389
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC m68k-tdep.c:426
- Function read_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function read_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC m68k-tdep.c:465
- Function read_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function read_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC m68k-tdep.c:532
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC m88k-tdep.c:165
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC m88k-tdep.c:192
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC m88k-tdep.c:311
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
+LOC m88k-tdep.c:312
+ Variable stack_word initialized to type LONGEST, expects int: num_stack_words
LOC m88k-tdep.c:316 (m88k-tdep.c:318)
+ Variable register_word initialized to type LONGEST, expects int: num_register_words
+LOC m88k-tdep.c:318
Right operand of && is non-boolean (int): register_word % 2 == 1 && m88k_8_byte_align_p(type)
LOC m88k-tdep.c:404
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC m88k-tdep.c:410
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC m88k-tdep.c:426
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC memrange.c:77
- Conditional clauses are not of same type: (ra->length) (int), ((rb->start - ra->start) + rb->length) (ULONGEST)
+ Conditional clauses are not of same type: (ra->length) (LONGEST), ((rb->start - ra->start) + rb->length) (ULONGEST)
LOC mep-tdep.c:1148
- Operands of == have incompatible types (UINT, size_t): (register_type(gdbarch, rawnum))->length == sizeof((buf64))
+ Operands of == have incompatible types (ULONGEST, size_t): (register_type(gdbarch, rawnum))->length == sizeof((buf64))
LOC mep-tdep.c:1234
- Operands of == have incompatible types (UINT, size_t): (register_type(gdbarch, rawnum))->length == sizeof((buf64))
+ Operands of == have incompatible types (ULONGEST, size_t): (register_type(gdbarch, rawnum))->length == sizeof((buf64))
LOC mep-tdep.c:2149
- Assignment of UINT to int: offset = (4) - (type)->length
+ Assignment of ULONGEST to int: offset = (4) - (type)->length
LOC mep-tdep.c:2155
- Function regcache_cooked_read_part expects arg 4 to be int gets UINT: (type)->length
+ Function regcache_cooked_read_part expects arg 4 to be int gets ULONGEST: (type)->length
LOC mep-tdep.c:2177
- Assignment of UINT to int: offset = (4) - (type)->length
+ Assignment of ULONGEST to int: offset = (4) - (type)->length
LOC mep-tdep.c:2182
- Function regcache_cooked_write_part expects arg 4 to be int gets UINT: (type)->length
+ Function regcache_cooked_write_part expects arg 4 to be int gets ULONGEST: (type)->length
LOC mep-tdep.c:2210
- Function read_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function read_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC mep-tdep.c:2289
- Function write_memory expects arg 3 to be ssize_t gets UINT: arg_len
+ Function write_memory expects arg 3 to be ssize_t gets ULONGEST: arg_len
LOC microblaze-tdep.c:571
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC microblaze-tdep.c:608
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
microblaze-tdep.c: (in function microblaze_return_value)
LOC mips-tdep.c:876
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC mips-tdep.c:908
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC mips-tdep.c:1024 (mips-tdep.c:1029)
+ Operands of == have incompatible types (UINT, ULONGEST): mips_abi_regsize(gdbarch) == (builtin_type(gdbarch)->builtin_data_ptr)->length
+LOC mips-tdep.c:1029
Fresh storage rawtype not released before return
LOC mips-tdep.c:4312 (mips-tdep.c:4311)
+ Function extract_signed_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:4311
New fresh storage (type gdb_byte *) passed as implicitly temp (not released): value_contents(arg)
LOC mips-tdep.c:4317 (mips-tdep.c:4318)
+ Function store_signed_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:4318
Function store_signed_integer expects arg 4 to be LONGEST gets CORE_ADDR: make_compact_addr(addr)
LOC mips-tdep.c:4397 (mips-tdep.c:4398)
+ Function extract_signed_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:4398
Test expression for if not boolean, type int: mips_debug
LOC mips-tdep.c:4400 (mips-tdep.c:4414)
+ Function phex expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:4414
Variable odd_sized_struct initialized to type boolean, expects int: (len > regsize && len % regsize != 0)
LOC mips-tdep.c:4422 (mips-tdep.c:4424)
+ Variable partial_len initialized to type LONGEST, expects int: (len < regsize ? len : regsize)
+LOC mips-tdep.c:4424
Test expression for if not boolean, type int: mips_debug
LOC mips-tdep.c:4444 (mips-tdep.c:4447)
- Operands of < have incompatible types (UINT, int): (arg_type)->length < regsize
+ Assignment of LONGEST to int: longword_offset = regsize - len
+LOC mips-tdep.c:4447
+ Operands of < have incompatible types (ULONGEST, int): (arg_type)->length < regsize
+LOC mips-tdep.c:4448
+ Assignment of LONGEST to int: longword_offset = regsize - len
LOC mips-tdep.c:4565
- Operands of < have incompatible types (int, UINT): offset < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): offset < (type)->length
LOC mips-tdep.c:4569
- Operands of > have incompatible types (int, UINT): offset + xfer > (type)->length
+ Operands of > have incompatible types (int, ULONGEST): offset + xfer > (type)->length
LOC mips-tdep.c:4570
- Assignment of UINT to int: xfer = (type)->length - offset
+ Assignment of ULONGEST to int: xfer = (type)->length - offset
LOC mips-tdep.c:4701
- Variable len initialized to type UINT, expects int: (arg_type)->length
+ Variable len initialized to type ULONGEST, expects int: (arg_type)->length
LOC mips-tdep.c:4937
- Operands of > have incompatible types (UINT, int): (type)->length > 2 * MIPS64_REGSIZE
+ Operands of > have incompatible types (ULONGEST, int): (type)->length > 2 * MIPS64_REGSIZE
LOC mips-tdep.c:4970
- Function mips_xfer_register expects arg 4 to be int gets UINT: (type)->length
+ Function mips_xfer_register expects arg 4 to be int gets ULONGEST: (type)->length
LOC mips-tdep.c:5020
- Function mips_xfer_register expects arg 4 to be int gets UINT: ((((type)->main_type->flds_bnds.fields[field]).type))->length
+ Function mips_xfer_register expects arg 4 to be int gets ULONGEST: ((((type)->main_type->flds_bnds.fields[field]).type))->length
LOC mips-tdep.c:5036
- Operands of < have incompatible types (int, UINT): offset < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): offset < (type)->length
LOC mips-tdep.c:5040
- Operands of > have incompatible types (int, UINT): offset + xfer > (type)->length
+ Operands of > have incompatible types (int, ULONGEST): offset + xfer > (type)->length
LOC mips-tdep.c:5041
- Assignment of UINT to int: xfer = (type)->length - offset
+ Assignment of ULONGEST to int: xfer = (type)->length - offset
LOC mips-tdep.c:5059
- Operands of < have incompatible types (int, UINT): offset < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): offset < (type)->length
LOC mips-tdep.c:5063
- Operands of > have incompatible types (int, UINT): offset + xfer > (type)->length
+ Operands of > have incompatible types (int, ULONGEST): offset + xfer > (type)->length
LOC mips-tdep.c:5064
- Assignment of UINT to int: xfer = (type)->length - offset
+ Assignment of ULONGEST to int: xfer = (type)->length - offset
LOC mips-tdep.c:5130 (mips-tdep.c:5128)
- Variable arglen initialized to type UINT, expects int: (arg_type)->length
-LOC mips-tdep.c:5131
Test expression for if not boolean, type int: mips_type_needs_double_align(arg_type)
LOC mips-tdep.c:5131 (mips-tdep.c:5132)
- Function align_up expects arg 1 to be ULONGEST gets int: len
-LOC mips-tdep.c:5132
- Assignment of ULONGEST to int: len = align_up(len, MIPS32_REGSIZE * 2)
+ Function align_up expects arg 1 to be ULONGEST gets LONGEST: len
LOC mips-tdep.c:5131 (mips-tdep.c:5134)
- Function align_up expects arg 1 to be ULONGEST gets int: arglen
+ Assignment of ULONGEST to LONGEST: len = align_up(len, MIPS32_REGSIZE * 2)
LOC mips-tdep.c:5102
- Previous definition of len: int
+ Previous definition of len: LONGEST
LOC mips-tdep.c:5241 (mips-tdep.c:5242)
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5241
Variable regval initialized to type ULONGEST, expects LONGEST: extract_unsigned_integer(val, len, byte_order)
LOC mips-tdep.c:5244 (mips-tdep.c:5247)
+ Function phex expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5246
Function regcache_cooked_write_unsigned expects arg 3 to be ULONGEST gets LONGEST: regval
LOC mips-tdep.c:5252 (mips-tdep.c:5254)
+ Function phex expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5253
Function regcache_cooked_write_unsigned expects arg 3 to be ULONGEST gets LONGEST: regval
LOC mips-tdep.c:5284 (mips-tdep.c:5287)
+ Variable partial_len initialized to type LONGEST, expects int: (len < MIPS32_REGSIZE ? len : MIPS32_REGSIZE)
+LOC mips-tdep.c:5286
Test expression for if not boolean, type int: mips_debug
LOC mips-tdep.c:5444 (mips-tdep.c:5445)
- Function mips_xfer_register expects arg 4 to be int gets UINT: (type)->length
+ Function mips_xfer_register expects arg 4 to be int gets ULONGEST: (type)->length
LOC mips-tdep.c:5450 (mips-tdep.c:5451)
- Function mips_xfer_register expects arg 4 to be int gets UINT: (type)->length
+ Function mips_xfer_register expects arg 4 to be int gets ULONGEST: (type)->length
LOC mips-tdep.c:5599 (mips-tdep.c:5600)
- Operands of < have incompatible types (int, UINT): offset < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): offset < (type)->length
LOC mips-tdep.c:5603 (mips-tdep.c:5604)
- Operands of > have incompatible types (int, UINT): offset + xfer > (type)->length
+ Operands of > have incompatible types (int, ULONGEST): offset + xfer > (type)->length
LOC mips-tdep.c:5604 (mips-tdep.c:5605)
- Assignment of UINT to int: xfer = (type)->length - offset
+ Assignment of ULONGEST to int: xfer = (type)->length - offset
LOC mips-tdep.c:5659 (mips-tdep.c:5657)
- Variable arglen initialized to type UINT, expects int: (arg_type)->length
-LOC mips-tdep.c:5660
- Function align_up expects arg 1 to be ULONGEST gets int: arglen
-LOC mips-tdep.c:5661
Fresh storage arg_type not released before scope exit
LOC mips-tdep.c:5630 (mips-tdep.c:5631)
- Previous definition of len: int
+ Previous definition of len: LONGEST
LOC mips-tdep.c:5708 (mips-tdep.c:5709)
+ Function extract_signed_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5707
New fresh storage (type gdb_byte *) passed as implicitly temp (not released): value_contents(arg)
LOC mips-tdep.c:5711 (mips-tdep.c:5714)
+ Function store_signed_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5712
Function store_signed_integer expects arg 4 to be LONGEST gets CORE_ADDR: make_compact_addr(addr)
LOC mips-tdep.c:5730 (mips-tdep.c:5732)
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5730
Variable regval initialized to type ULONGEST, expects LONGEST: extract_unsigned_integer(val, len, byte_order)
LOC mips-tdep.c:5733 (mips-tdep.c:5736)
+ Function phex expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5734
Function regcache_cooked_write_unsigned expects arg 3 to be ULONGEST gets LONGEST: regval
LOC mips-tdep.c:5737 (mips-tdep.c:5740)
+ Function phex expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5738
Function regcache_cooked_write_unsigned expects arg 3 to be ULONGEST gets LONGEST: regval
LOC mips-tdep.c:5758 (mips-tdep.c:5762)
+ Variable partial_len initialized to type LONGEST, expects int: (len < MIPS64_REGSIZE ? len : MIPS64_REGSIZE)
+LOC mips-tdep.c:5760
Test expression for if not boolean, type int: mips_debug
LOC mips-tdep.c:5779 (mips-tdep.c:5784)
+ Assignment of LONGEST to int: longword_offset = MIPS64_REGSIZE - len
+LOC mips-tdep.c:5782
Test expression for if not boolean, type int: mips_debug
LOC mips-tdep.c:5785 (mips-tdep.c:5787)
- Function paddress expects arg 2 to be CORE_ADDR gets int: stack_offset
+ Function paddress expects arg 2 to be CORE_ADDR gets LONGEST: stack_offset
LOC mips-tdep.c:5909 (mips-tdep.c:5911)
- Function mips_xfer_register expects arg 4 to be int gets UINT: (type)->length
+ Function mips_xfer_register expects arg 4 to be int gets ULONGEST: (type)->length
LOC mips-tdep.c:5915 (mips-tdep.c:5917)
- Function mips_xfer_register expects arg 4 to be int gets UINT: (type)->length
+ Function mips_xfer_register expects arg 4 to be int gets ULONGEST: (type)->length
LOC mips-tdep.c:5927 (mips-tdep.c:5929)
- Operands of < have incompatible types (int, UINT): offset < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): offset < (type)->length
LOC mips-tdep.c:5931 (mips-tdep.c:5933)
- Operands of > have incompatible types (int, UINT): offset + xfer > (type)->length
+ Operands of > have incompatible types (int, ULONGEST): offset + xfer > (type)->length
LOC mips-tdep.c:5932 (mips-tdep.c:5934)
- Assignment of UINT to int: xfer = (type)->length - offset
+ Assignment of ULONGEST to int: xfer = (type)->length - offset
LOC mn10300-tdep.c:103 (mn10300-tdep.c:102)
- Return value type UINT does not match declared type int: (type)->length
+ Return value type ULONGEST does not match declared type LONGEST: (type)->length
LOC mn10300-tdep.c:106 (mn10300-tdep.c:105)
- Return value type UINT does not match declared type int: (type)->length / 2
+ Return value type ULONGEST does not match declared type LONGEST: (type)->length / 2
LOC mn10300-tdep.c:114 (mn10300-tdep.c:113)
- Left operand of <<= may be negative (int): align <<= 1
+ Left operand of <<= may be negative (LONGEST): align <<= 1
LOC mn10300-tdep.c:129 (mn10300-tdep.c:128)
- Path with no return in function declared to return int
+ Path with no return in function declared to return LONGEST
mn10300-tdep.c: (in function mn10300_use_struct_convention)
LOC mn10300-tdep.c:174 (mn10300-tdep.c:173)
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC mn10300-tdep.c:203 (mn10300-tdep.c:202)
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
+LOC moxie-tdep.c:135
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len - 4
LOC moxie-tdep.c:330 (moxie-tdep.c:336)
+ Function store_unsigned_integer expects arg 2 to be int gets LONGEST: (len > 4 ? len - 4 : len)
+LOC moxie-tdep.c:336
Return value (type enum register_status) ignored: regcache_cooked_...
LOC mt-tdep.c:353
- Function read_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function read_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC mt-tdep.c:361
- Function write_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function write_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC mt-tdep.c:386
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC mt-tdep.c:786
- Variable stack_dest initialized to type CORE_ADDR, expects int: sp
+ Variable stack_dest initialized to type CORE_ADDR, expects LONGEST: sp
LOC mt-tdep.c:827 (mt-tdep.c:828)
- Function memcpy expects arg 3 to be size_t gets int: typelen
+ Assignment of LONGEST to int: split_param_len = typelen
+LOC mt-tdep.c:828
+ Function memcpy expects arg 3 to be size_t gets LONGEST: typelen
LOC mt-tdep.c:838
- Function write_memory expects arg 1 to be CORE_ADDR gets int: stack_dest
+ Function write_memory expects arg 1 to be CORE_ADDR gets LONGEST: stack_dest
LOC mt-tdep.c:838
- Function write_memory expects arg 3 to be ssize_t gets int: typelen
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: typelen
LOC mt-tdep.c:851 (mt-tdep.c:852)
- Function C_alloca expects arg 1 to be size_t gets int: typelen + slacklen
+ Assignment of LONGEST to int: slacklen = (4 - (typelen % 4)) % 4
LOC mt-tdep.c:852 (mt-tdep.c:853)
- Function memcpy expects arg 3 to be size_t gets int: typelen
+ Function C_alloca expects arg 1 to be size_t gets LONGEST: typelen + slacklen
+LOC mt-tdep.c:853
+ Function memcpy expects arg 3 to be size_t gets LONGEST: typelen
LOC mt-tdep.c:857
- Function write_memory expects arg 1 to be CORE_ADDR gets int: stack_dest
+ Function write_memory expects arg 1 to be CORE_ADDR gets LONGEST: stack_dest
LOC mt-tdep.c:857
- Function write_memory expects arg 3 to be ssize_t gets int: typelen + slacklen
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: typelen + slacklen
LOC mt-tdep.c:865
- Function write_memory expects arg 1 to be CORE_ADDR gets int: stack_dest
+ Function write_memory expects arg 1 to be CORE_ADDR gets LONGEST: stack_dest
LOC mt-tdep.c:882
- Return value type int does not match declared type CORE_ADDR: stack_dest
+ Return value type LONGEST does not match declared type CORE_ADDR: stack_dest
LOC objc-lang.c:371 (objc-lang.c:379)
+ Operands of < have incompatible types (UINT, ULONGEST): i < length
+LOC objc-lang.c:379
Test expression for if not boolean, type int: quit_flag
LOC objc-lang.c:389 (objc-lang.c:397)
+ Operands of < have incompatible types (UINT, ULONGEST): rep1 < length
+LOC objc-lang.c:397
Test expression for if not boolean, type int: in_quotes
LOC objc-lang.c:435
+ Operands of < have incompatible types (UINT, ULONGEST): i < length
+LOC objc-lang.c:435
Left operand of || is non-boolean (int): force_ellipses || i < length
LOC opencl-lang.c:191 (opencl-lang.c:190)
- Assignment of LONGEST to int: n = offset + highb - lowb + 1
-LOC opencl-lang.c:191
New fresh storage (type char *) passed as implicitly temp (not released): gettext("Assertion `%s' failed.")
LOC opencl-lang.c:196
- Function memcpy expects arg 3 to be size_t gets int: elsize
+ Function memcpy expects arg 3 to be size_t gets LONGEST: elsize
LOC opencl-lang.c:236 (opencl-lang.c:219)
- Assignment of LONGEST to int: n = offset + highb - lowb + 1
-LOC opencl-lang.c:236
- Function memcpy expects arg 3 to be size_t gets int: elsize
+ Function memcpy expects arg 3 to be size_t gets LONGEST: elsize
+LOC opencl-lang.c:253
+ Variable startrest initialized to type LONGEST, expects int: offset % elsize
+LOC opencl-lang.c:255
+ Variable endrest initialized to type LONGEST, expects int: (offset + length) % elsize
LOC opencl-lang.c:268 (opencl-lang.c:269)
+ Conditional clauses are not of same type: endrest (int), elsize (LONGEST)
+LOC opencl-lang.c:270
Operand of ! is non-boolean (int): !value_bits_valid(c->val, c->indices[i] * elsize + comp_offset, comp_length)
+LOC opencl-lang.c:307
+ Variable startrest initialized to type LONGEST, expects int: offset % elsize
+LOC opencl-lang.c:309
+ Variable endrest initialized to type LONGEST, expects int: (offset + length) % elsize
LOC opencl-lang.c:322 (opencl-lang.c:323)
+ Conditional clauses are not of same type: endrest (int), elsize (LONGEST)
+LOC opencl-lang.c:324
Operand of ! is non-boolean (int): !value_bits_synthetic_pointer(c->val, c->indices[i] * elsize + comp_offset, comp_length)
LOC opencl-lang.c:428 (opencl-lang.c:427)
- Function memcpy expects arg 3 to be size_t gets UINT: (elm_type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (elm_type)->length
LOC opencl-lang.c:581 (opencl-lang.c:580)
- Function memset expects arg 3 to be size_t gets UINT: (eltype)->length
+ Function memset expects arg 3 to be size_t gets ULONGEST: (eltype)->length
LOC opencl-lang.c:681 (opencl-lang.c:680)
- Function memset expects arg 3 to be size_t gets UINT: (eltype1)->length
+ Function memset expects arg 3 to be size_t gets ULONGEST: (eltype1)->length
LOC opencl-lang.c:901 (opencl-lang.c:900)
- Function memcpy expects arg 3 to be size_t gets UINT: (eltype2)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (eltype2)->length
LOC p-lang.c:233
- Assignment of UINT to int: width = (type)->length
+ Assignment of ULONGEST to int: width = (type)->length
LOC p-lang.c:249 (p-lang.c:258)
+ Operands of < have incompatible types (UINT, ULONGEST): i < length
+LOC p-lang.c:258
Test expression for if not boolean, type int: quit_flag
LOC p-lang.c:271 (p-lang.c:281)
+ Operands of < have incompatible types (UINT, ULONGEST): rep1 < length
+LOC p-lang.c:281
Test expression for if not boolean, type int: in_quotes
LOC p-lang.c:319
+ Operands of < have incompatible types (UINT, ULONGEST): i < length
+LOC p-lang.c:319
Left operand of || is non-boolean (int): force_ellipses || i < length
ppc-linux-nat.c: (in function ppc_linux_can_accel_watchpoint_condition)
LOC ppc-linux-nat.c:2030 (ppc-linux-nat.c:2057)
+ Function calculate_dvc expects arg 2 to be int gets LONGEST: len
+LOC ppc-linux-nat.c:2057
Assignment of int to uint32_t: p->trigger_type = get_trigger_type(rw)
ppc-linux-nat.c: (in function ppc_linux_insert_watchpoint)
+LOC ppc-sysv-tdep.c:162
+ Function align_up expects arg 2 to be int gets LONGEST: len
LOC ppc-sysv-tdep.c:164
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC ppc-sysv-tdep.c:193
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC ppc-sysv-tdep.c:215
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC ppc-sysv-tdep.c:250
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
+LOC ppc-sysv-tdep.c:304
+ Function align_up expects arg 2 to be int gets LONGEST: len
LOC ppc-sysv-tdep.c:308
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC ppc-sysv-tdep.c:380
- Assignment of ULONGEST to int: argoffset = align_up(argoffset, len)
+ Function align_up expects arg 2 to be int gets LONGEST: len
+LOC ppc-sysv-tdep.c:380
+ Assignment of ULONGEST to LONGEST: argoffset = align_up(argoffset, len)
LOC ppc-sysv-tdep.c:382
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC ppc-sysv-tdep.c:395
- Function write_memory expects arg 3 to be ssize_t gets UINT: (eltype)->length
+ Function write_memory expects arg 3 to be ssize_t gets ULONGEST: (eltype)->length
LOC ppc-sysv-tdep.c:447 (ppc-sysv-tdep.c:453)
+ Operands of < have incompatible types (int, LONGEST): i < len / 16
+LOC ppc-sysv-tdep.c:453
Test expression for if not boolean, type int: write_pass
LOC ppc-sysv-tdep.c:537
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC ppc-sysv-tdep.c:550
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC ppc-sysv-tdep.c:574 (ppc-sysv-tdep.c:587)
+ Assignment of LONGEST to int: argspace = argoffset
+LOC ppc-sysv-tdep.c:587
Test expression for if not boolean, type int: write_pass
LOC ppc-sysv-tdep.c:814
- Operands of <= have incompatible types (UINT, int): (type)->length <= tdep->wordsize
+ Operands of <= have incompatible types (ULONGEST, int): (type)->length <= tdep->wordsize
+LOC ppc-sysv-tdep.c:852
+ Variable regnum initialized to type LONGEST, expects int: tdep->ppc_fp0_regnum + 1 + i
LOC ppc-sysv-tdep.c:871 (ppc-sysv-tdep.c:876)
+ Variable regnum initialized to type LONGEST, expects int: tdep->ppc_gp0_regnum + 3 + i
+LOC ppc-sysv-tdep.c:876
Assignment of LONGEST to ULONGEST: regval = unpack_long(eltype, writebuf + offset)
LOC ppc-sysv-tdep.c:897
- Variable n_regs initialized to type UINT, expects int: (type)->length / 16
+ Variable n_regs initialized to type ULONGEST, expects int: (type)->length / 16
LOC ppc-sysv-tdep.c:984
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC ppc-sysv-tdep.c:1019
- Operands of > have incompatible types (UINT, int): (type)->length > tdep->wordsize
+ Operands of > have incompatible types (ULONGEST, int): (type)->length > tdep->wordsize
LOC ppc-sysv-tdep.c:1022
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC ppc-sysv-tdep.c:1031
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC ppc-sysv-tdep.c:1034
- Operands of > have incompatible types (UINT, int): (type)->length > tdep->wordsize
+ Operands of > have incompatible types (ULONGEST, int): (type)->length > tdep->wordsize
LOC ppc-sysv-tdep.c:1304
- Function write_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function write_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC ppc-sysv-tdep.c:1360
- Function write_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function write_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC ppc-sysv-tdep.c:1375
- Variable nelt initialized to type UINT, expects int: (type)->length / (eltype)->length
+ Variable nelt initialized to type ULONGEST, expects int: (type)->length / (eltype)->length
LOC ppc-sysv-tdep.c:1448
- Operands of < have incompatible types (int, UINT): i < (type)->length / 16
+ Operands of < have incompatible types (int, ULONGEST): i < (type)->length / 16
LOC ppc-sysv-tdep.c:1487
- Function write_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function write_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC ppc-sysv-tdep.c:1502
- Function write_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function write_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
LOC ppc-sysv-tdep.c:1561
- Operands of < have incompatible types (int, UINT): byte < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): byte < (type)->length
LOC ppc-sysv-tdep.c:1567
- Variable len initialized to type UINT, expects int: (type)->length - byte
+ Variable len initialized to type ULONGEST, expects int: (type)->length - byte
LOC ppc-sysv-tdep.c:1597
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC ppc-sysv-tdep.c:1599
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC ppc-sysv-tdep.c:1792
- Variable nelt initialized to type UINT, expects int: (valtype)->length / (eltype)->length
+ Variable nelt initialized to type ULONGEST, expects int: (valtype)->length / (eltype)->length
+LOC ppc-sysv-tdep.c:1796
+ Variable offset initialized to type ULONGEST, expects int: i * (eltype)->length
+LOC ppc-sysv-tdep.c:1851
+ Variable regnum initialized to type LONGEST, expects int: tdep->ppc_vr0_regnum + 2 + i
LOC ppc-sysv-tdep.c:1869 (ppc-sysv-tdep.c:1873)
- Function regcache_cooked_write_part expects arg 4 to be int gets UINT: (valtype)->length
+ Variable offset initialized to type ULONGEST, expects int: (register_size(gdbarch, tdep->ppc_gp0_regnum + 3) - (valtype)->length)
LOC ppc-sysv-tdep.c:1873 (ppc-sysv-tdep.c:1876)
- Function regcache_cooked_read_part expects arg 4 to be int gets UINT: (valtype)->length
+ Function regcache_cooked_write_part expects arg 4 to be int gets ULONGEST: (valtype)->length
+LOC ppc-sysv-tdep.c:1876
+ Function regcache_cooked_read_part expects arg 4 to be int gets ULONGEST: (valtype)->length
LOC ppc-sysv-tdep.c:1900
- Operands of < have incompatible types (int, UINT): i < (valtype)->length / 8
+ Operands of < have incompatible types (int, ULONGEST): i < (valtype)->length / 8
LOC printcmd.c:384
- Operands of > have incompatible types (UINT, size_t): len > sizeof(LONGEST)
+ Operands of > have incompatible types (ULONGEST, size_t): len > sizeof(LONGEST)
+LOC printcmd.c:391
+ Function print_octal_chars expects arg 3 to be UINT gets ULONGEST: len
LOC printcmd.c:395 (printcmd.c:396)
+ Function print_decimal_chars expects arg 3 to be UINT gets ULONGEST: len
+LOC printcmd.c:396
Fresh storage gdbarch not released before return
LOC printcmd.c:398 (printcmd.c:399)
+ Function print_binary_chars expects arg 3 to be UINT gets ULONGEST: len
+LOC printcmd.c:399
Fresh storage gdbarch not released before return
LOC printcmd.c:404 (printcmd.c:405)
+ Function print_char_chars expects arg 4 to be UINT gets ULONGEST: len
+LOC printcmd.c:405
Fresh storage gdbarch not released before return
LOC printcmd.c:425
- Operands of < have incompatible types (UINT, size_t): len < sizeof(LONGEST)
+ Operands of < have incompatible types (ULONGEST, size_t): len < sizeof(LONGEST)
LOC printcmd.c:2395
- Variable wcwidth initialized to type UINT, expects int: (wctype)->length
+ Variable wcwidth initialized to type ULONGEST, expects int: (wctype)->length
LOC printcmd.c:2454 (printcmd.c:2455)
- Function convert_between_encodings expects arg 5 to be int gets UINT: (valtype)->length
+ Function convert_between_encodings expects arg 4 to be UINT gets ULONGEST: (valtype)->length
+LOC printcmd.c:2455
+ Function convert_between_encodings expects arg 5 to be int gets ULONGEST: (valtype)->length
LOC printcmd.c:2547 (printcmd.c:2609)
+ Variable param_len initialized to type ULONGEST, expects UINT: (param_type)->length
+LOC printcmd.c:2609
Function decimal_convert expects arg 2 to be int gets UINT: param_len
LOC p-typeprint.c:821 (p-typeprint.c:753)
- Operands of != have incompatible types (int, LONGEST): lastval != ((((type)->main_type->flds_bnds.fields[i]).loc.enumval) + 0)
-LOC p-typeprint.c:758
- Assignment of LONGEST to int: lastval = ((((type)->main_type->flds_bnds.fields[i]).loc.enumval) + 0)
-LOC p-typeprint.c:821
Fresh storage type not released before return
LOC p-valprint.c:212 (p-valprint.c:211)
- Function xmalloc expects arg 1 to be size_t gets int: length_size
+ Function xmalloc expects arg 1 to be size_t gets LONGEST: length_size
LOC p-valprint.c:213 (p-valprint.c:212)
- Function read_memory expects arg 3 to be ssize_t gets int: length_size
+ Function read_memory expects arg 3 to be ssize_t gets LONGEST: length_size
+LOC p-valprint.c:214
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: length_size
LOC p-valprint.c:324 (p-valprint.c:322)
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: length_size
+LOC p-valprint.c:323
Assignment of ULONGEST to UINT: len = extract_unsigned_integer(valaddr + embedded_offset + length_pos, length_size, byte_order)
LOC p-valprint.c:802 (p-valprint.c:801)
- Function C_alloca expects arg 1 to be size_t gets UINT: (baseclass)->length
+ Function C_alloca expects arg 1 to be size_t gets ULONGEST: (baseclass)->length
LOC p-valprint.c:806 (p-valprint.c:805)
- Function target_read_memory expects arg 3 to be ssize_t gets UINT: (baseclass)->length
+ Function target_read_memory expects arg 3 to be ssize_t gets ULONGEST: (baseclass)->length
LOC python/py-prettyprint.c:355
- Function expects arg 4 to be UINT gets LONGEST: length
+ Function expects arg 4 to be ULONGEST gets LONGEST: length
regcache.c: (in function regcache_cooked_read_signed)
LOC regcache.c:915
- Operands of <= have incompatible types (int, LONGEST): offset <= descr->sizeof_register[regnum]
-LOC regcache.c:915
New fresh storage (type char *) passed as implicitly temp (not released): gettext("Assertion `%s' failed.")
LOC regcache.c:916
- Operands of <= have incompatible types (int, LONGEST): offset + len <= descr->sizeof_register[regnum]
-LOC regcache.c:916
New fresh storage (type char *) passed as implicitly temp (not released): gettext("Assertion `%s' failed.")
LOC regcache.c:927 (regcache.c:923)
- Operands of < have incompatible types (int, LONGEST): offset + len < descr->sizeof_register[regnum]
-LOC regcache.c:927
New fresh storage (type char *) passed as implicitly temp (not released): gettext("Assertion `%s' failed.")
LOC remote.c:7971
+ Function phex_nz expects arg 1 to be ULONGEST gets LONGEST: len
+LOC remote.c:7971
Function xsnprintf expects arg 2 to be size_t gets int: endbuf - p
LOC remote.c:8015
+ Function phex_nz expects arg 1 to be ULONGEST gets LONGEST: len
+LOC remote.c:8015
Function xsnprintf expects arg 2 to be size_t gets int: endbuf - p
LOC remote-m32r-sdi.c:1433
- Assignment of int to UINT: ab_size[i] = len
+ Assignment of LONGEST to UINT: ab_size[i] = len
LOC remote-mips.c:2434 (remote-mips.c:2433)
Parameter cond not used
+remote-mips.c: (in function mips_set_breakpoint)
+LOC remote-mips.c:2457
+ Function mips_common_breakpoint expects arg 3 to be int gets LONGEST: len
+remote-mips.c: (in function mips_clear_breakpoint)
+LOC remote-mips.c:2466
+ Function mips_common_breakpoint expects arg 3 to be int gets LONGEST: len
remote-mips.c: (in function mips_check_lsi_error)
rl78-tdep.c: (in function rl78_pointer_to_address)
LOC rl78-tdep.c:1027
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC rs6000-aix-tdep.c:277 (rs6000-aix-tdep.c:280)
+ Operands of < have incompatible types (int, LONGEST): argbytes < len
+LOC rs6000-aix-tdep.c:280
Function memset expects arg 3 to be size_t gets int: reg_size
LOC rs6000-aix-tdep.c:284 (rs6000-aix-tdep.c:283)
- Function memcpy expects arg 3 to be size_t gets int: (len - argbytes) > reg_size ? reg_size : len - argbytes
+ Conditional clauses are not of same type: reg_size (int), len - argbytes (LONGEST)
+LOC rs6000-aix-tdep.c:299
+ Variable adj initialized to type LONGEST, expects int: gdbarch_byte_order(gdbarch) == BFD_ENDIAN_BIG ? reg_size - len : 0
LOC rs6000-aix-tdep.c:304
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC rs6000-aix-tdep.c:366
- Function write_memory expects arg 3 to be ssize_t gets int: len - argbytes
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len - argbytes
LOC rs6000-aix-tdep.c:393
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC rs6000-aix-tdep.c:494
- Operands of <= have incompatible types (UINT, int): (valtype)->length <= tdep->wordsize
+ Operands of <= have incompatible types (ULONGEST, int): (valtype)->length <= tdep->wordsize
s390-tdep.c: (in function s390_pseudo_register_reggroup_p)
LOC s390-tdep.c:2495 (s390-tdep.c:2496)
+ Function is_power_of_two expects arg 1 to be UINT gets ULONGEST: (type)->length
+LOC s390-tdep.c:2495
Operand of ! is non-boolean (int): !is_power_of_two((type)->length)
LOC s390-tdep.c:2516 (s390-tdep.c:2522)
+ Variable length initialized to type ULONGEST, expects UINT: (type)->length
+LOC s390-tdep.c:2520
Operands of || are non-boolean (int): is_integer_like(type) || is_pointer_like(type)
LOC s390-tdep.c:2555 (s390-tdep.c:2557)
- Assignment of UINT to int: alignment = (type)->length
+ Assignment of ULONGEST to int: alignment = (type)->length
LOC s390-tdep.c:2675 (s390-tdep.c:2678)
- Function write_memory expects arg 3 to be ssize_t gets UINT: length
+ Function write_memory expects arg 3 to be ssize_t gets ULONGEST: length
LOC s390-tdep.c:2699 (s390-tdep.c:2702)
- Function regcache_cooked_write_part expects arg 4 to be int gets UINT: length
+ Function regcache_cooked_write_part expects arg 4 to be int gets ULONGEST: length
LOC s390-tdep.c:2707 (s390-tdep.c:2710)
- Function write_memory expects arg 3 to be ssize_t gets UINT: length
+ Function write_memory expects arg 3 to be ssize_t gets ULONGEST: length
LOC s390-tdep.c:2710 (s390-tdep.c:2713)
- Operands of <= have incompatible types (UINT, int): length <= word_size
+ Operands of <= have incompatible types (ULONGEST, int): length <= word_size
LOC s390-tdep.c:2728 (s390-tdep.c:2731)
- Operands of == have incompatible types (UINT, int): length == 2 * word_size
+ Operands of == have incompatible types (ULONGEST, int): length == 2 * word_size
LOC s390-tdep.c:2744 (s390-tdep.c:2747)
- Function write_memory expects arg 3 to be ssize_t gets UINT: length
+ Function write_memory expects arg 3 to be ssize_t gets ULONGEST: length
LOC s390-tdep.c:2797 (s390-tdep.c:2802)
- Variable length initialized to type UINT, expects int: (type)->length
-LOC s390-tdep.c:2800
Parameter gdbarch not used
s390-tdep.c: (in function s390_return_value)
+LOC s390-tdep.c:2840
+ Function regcache_cooked_write_part expects arg 4 to be int gets LONGEST: length
LOC s390-tdep.c:2847 (s390-tdep.c:2862)
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: length
+LOC s390-tdep.c:2850
+ Function extract_signed_integer expects arg 2 to be int gets LONGEST: length
+LOC s390-tdep.c:2858
New fresh storage (type char *) passed as implicitly temp (not released): gettext("invalid return type")
LOC s390-tdep.c:2877 (s390-tdep.c:2880)
+ Function regcache_cooked_read_part expects arg 4 to be int gets LONGEST: length
+LOC s390-tdep.c:2876
Return value (type enum register_status) ignored: regcache_cooked_...
LOC s390-tdep.c:2883 (s390-tdep.c:2886)
+ Function regcache_cooked_read_part expects arg 4 to be int gets LONGEST: length
+LOC s390-tdep.c:2882
Return value (type enum register_status) ignored: regcache_cooked_...
LOC score-tdep.c:465
- Operands of < have incompatible types (int, UINT): offset < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): offset < (type)->length
LOC score-tdep.c:470
- Operands of > have incompatible types (int, UINT): offset + xfer > (type)->length
+ Operands of > have incompatible types (int, ULONGEST): offset + xfer > (type)->length
LOC score-tdep.c:471
- Assignment of UINT to int: xfer = (type)->length - offset
+ Assignment of ULONGEST to int: xfer = (type)->length - offset
LOC score-tdep.c:592 (score-tdep.c:602)
+ Variable partial_len initialized to type LONGEST, expects int: arglen < 4 ? arglen : 4
+LOC score-tdep.c:602
Right operand of <<= may be negative (int): regval <<= ((4 - partial_len) * 8)
LOC sh64-tdep.c:1116
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC sh64-tdep.c:1118
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC sh64-tdep.c:1269 (sh64-tdep.c:1273)
- Function memcpy expects arg 3 to be size_t gets int: len
+ Assignment of LONGEST to int: offset = register_size(gdbarch, DEFAULT_RETURN_REGNUM) - len
+LOC sh64-tdep.c:1273
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
+LOC sh64-tdep.c:1298
+ Operands of < have incompatible types (int, LONGEST): i < len
LOC sh64-tdep.c:1318 (sh64-tdep.c:1320)
- Function memcpy expects arg 3 to be size_t gets int: len
+ Assignment of LONGEST to int: offset = register_size(gdbarch, return_register) - len
+LOC sh64-tdep.c:1320
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC sh-tdep.c:808
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sh-tdep.c:828
- Operands of == have incompatible types (UINT, int): ((((type)->main_type->flds_bnds.fields[0]).type))->length == len
+ Operands of == have incompatible types (ULONGEST, int): ((((type)->main_type->flds_bnds.fields[0]).type))->length == len
sh-tdep.c: (in function sh_use_struct_convention_nofpu)
LOC sh-tdep.c:1035
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sh-tdep.c:1099
- Assignment of UINT to int: len = (type)->length
+ Assignment of ULONGEST to int: len = (type)->length
LOC sh-tdep.c:1148
- Operands of == have incompatible types (UINT, int): (type)->length == 2 * reg_size
+ Operands of == have incompatible types (ULONGEST, int): (type)->length == 2 * reg_size
LOC sh-tdep.c:1236
- Assignment of UINT to int: len = (type)->length
+ Assignment of ULONGEST to int: len = (type)->length
LOC sh-tdep.c:1318 (sh-tdep.c:1324)
+ Function store_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC sh-tdep.c:1323
+ Operands of < have incompatible types (int, LONGEST): i < len
+LOC sh-tdep.c:1324
Function regcache_raw_read expects arg 3 to be gdb_byte * gets char *: (char *)valbuf + i
LOC sh-tdep.c:1337
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
+LOC sh-tdep.c:1367
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC sh-tdep.c:1373
+ Operands of < have incompatible types (int, LONGEST): i < len
LOC sh-tdep.c:1385
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc64-tdep.c:67
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc64-tdep.c:74
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc64-tdep.c:94
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc64-tdep.c:114
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc64-tdep.c:645 (sparc64-tdep.c:644)
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc64-tdep.c:666 (sparc64-tdep.c:670)
+ Assignment of LONGEST to int: regnum = SPARC64_D0_REGNUM + element + bitpos / 64
+LOC sparc64-tdep.c:671
New fresh storage (type char *) passed as implicitly temp (not released): gettext("Assertion `%s' failed.")
LOC sparc64-tdep.c:674 (sparc64-tdep.c:677)
+ Assignment of LONGEST to int: regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32
+LOC sparc64-tdep.c:678
Test expression for if not boolean, type int: sparc64_structure_or_union_p(type)
LOC sparc64-tdep.c:721 (sparc64-tdep.c:720)
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc64-tdep.c:728
+ Assignment of LONGEST to int: regnum = SPARC64_Q0_REGNUM + bitpos / 128
+LOC sparc64-tdep.c:729
Return value (type enum register_status) ignored: regcache_cooked_...
LOC sparc64-tdep.c:735
+ Assignment of LONGEST to int: regnum = SPARC64_D0_REGNUM + bitpos / 64
+LOC sparc64-tdep.c:736
Return value (type enum register_status) ignored: regcache_cooked_...
LOC sparc64-tdep.c:743
+ Assignment of LONGEST to int: regnum = SPARC_F0_REGNUM + bitpos / 32
+LOC sparc64-tdep.c:744
Return value (type enum register_status) ignored: regcache_cooked_...
LOC sparc64-tdep.c:816 (sparc64-tdep.c:815)
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC sparc64-tdep.c:887 (sparc64-tdep.c:886)
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc64-tdep.c:1024 (sparc64-tdep.c:1023)
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc64-tdep.c:1074 (sparc64-tdep.c:1073)
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc-tdep.c:181
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc-tdep.c:214
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc-tdep.c:233
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc-tdep.c:486
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC sparc-tdep.c:524
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc-tdep.c:1254
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc-tdep.c:1308
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC sparc-tdep.c:1379
- Function read_memory expects arg 3 to be ssize_t gets UINT: (type)->length
+ Function read_memory expects arg 3 to be ssize_t gets ULONGEST: (type)->length
+LOC spu-tdep.c:323
+ Variable preferred_slot initialized to type LONGEST, expects int: len < 4 ? 4 - len : 0
spu-tdep.c: (in function spu_gdbarch_id)
spu-tdep.c: (in function spu_pointer_to_address)
LOC spu-tdep.c:1296
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC spu-tdep.c:1321
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC spu-tdep.c:1376
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC spu-tdep.c:1409
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC spu-tdep.c:1475
- Operands of <= have incompatible types (UINT, int): (type)->length <= (SPU_ARGN_REGNUM - SPU_ARG1_REGNUM + 1) * 16
+ Operands of <= have incompatible types (ULONGEST, int): (type)->length <= (SPU_ARGN_REGNUM - SPU_ARG1_REGNUM + 1) * 16
LOC tracepoint.c:1483 (tracepoint.c:1482)
- Function add_memrange expects arg 3 to be bfd_signed_vma gets ULONGEST: addr
+ Function add_memrange expects arg 3 to be bfd_signed_vma gets CORE_ADDR: addr
LOC tracepoint.c:4687 (tracepoint.c:4682)
- Assignment of unsigned short int to int: r->length = mlen
+ Assignment of unsigned short int to LONGEST: r->length = mlen
LOC v850-tdep.c:812
- Previous definition of len: int
+ Previous definition of len: LONGEST
LOC v850-tdep.c:851
- Assignment of UINT to int: len = (value_type(*args))->length
+ Assignment of ULONGEST to int: len = (value_type(*args))->length
LOC v850-tdep.c:900 (v850-tdep.c:908)
+ Function store_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC v850-tdep.c:908
Passed storage buf not completely defined (*buf is undefined): regcache_raw_read (..., buf)
+LOC v850-tdep.c:925
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC v850-tdep.c:929
+ Operands of < have incompatible types (int, LONGEST): i < len
LOC valarith.c:713
- Assignment of UINT to int: inval2len = (type2)->length
+ Assignment of ULONGEST to int: inval2len = (type2)->length
LOC valarith.c:757
- Assignment of UINT to int: inval1len = (type1)->length
+ Assignment of ULONGEST to int: inval1len = (type1)->length
LOC valarith.c:758
- Assignment of UINT to int: inval2len = (type2)->length
+ Assignment of ULONGEST to int: inval2len = (type2)->length
LOC valarith.c:895
- Assignment of UINT to int: *len_x = (type1)->length
+ Assignment of ULONGEST to int: *len_x = (type1)->length
LOC valarith.c:901
- Assignment of UINT to int: *len_x = (type2)->length
+ Assignment of ULONGEST to int: *len_x = (type2)->length
LOC valarith.c:914
- Assignment of UINT to int: *len_y = (type2)->length
+ Assignment of ULONGEST to int: *len_y = (type2)->length
LOC valarith.c:920
- Assignment of UINT to int: *len_y = (type1)->length
+ Assignment of ULONGEST to int: *len_y = (type1)->length
LOC valarith.c:973
- Assignment of UINT to int: len_v = (result_type)->length
+ Assignment of ULONGEST to int: len_v = (result_type)->length
LOC valarith.c:1414
- Assignment of UINT to int: elsize = (eltype1)->length
+ Assignment of ULONGEST to int: elsize = (eltype1)->length
LOC valarith.c:1417
- Operands of != have incompatible types (int, UINT): elsize != (eltype2)->length
+ Operands of != have incompatible types (int, ULONGEST): elsize != (eltype2)->length
LOC valarith.c:1487
- Function decimal_is_zero expects arg 2 to be int gets UINT: (type1)->length
+ Function decimal_is_zero expects arg 2 to be int gets ULONGEST: (type1)->length
+LOC valarith.c:1512
+ Variable len initialized to type LONGEST, expects int: len1 < len2 ? len1 : len2
LOC valarith.c:1628
- Function memcmp expects arg 3 to be size_t gets UINT: (type1)->length
+ Function memcmp expects arg 3 to be size_t gets ULONGEST: (type1)->length
LOC valarith.c:1718
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC valarith.c:1739
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC valarith.c:1772
- Function memcpy expects arg 3 to be size_t gets UINT: (eltype)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (eltype)->length
LOC valarith.c:1809
- Function memcpy expects arg 3 to be size_t gets UINT: (eltype)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (eltype)->length
LOC valops.c:474 (valops.c:473)
- Variable dec_len initialized to type UINT, expects int: (type)->length
+ Variable dec_len initialized to type ULONGEST, expects int: (type)->length
LOC valops.c:480 (valops.c:479)
- Function decimal_convert expects arg 2 to be int gets UINT: (type2)->length
+ Function decimal_convert expects arg 2 to be int gets ULONGEST: (type2)->length
LOC valops.c:569 (valops.c:568)
- Function memcpy expects arg 3 to be size_t gets UINT: (eltype)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (eltype)->length
LOC valops.c:884 (valops.c:882)
- Function decimal_from_string expects arg 2 to be int gets UINT: (type)->length
+ Function decimal_from_string expects arg 2 to be int gets ULONGEST: (type)->length
LOC valops.c:910 (valops.c:908)
- Function memcpy expects arg 3 to be size_t gets UINT: (eltype)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (eltype)->length
LOC valops.c:999 (valops.c:997)
- Variable length initialized to type UINT, expects int: (type)->length
-LOC valops.c:1000
- Function value_bits_valid expects arg 2 to be int gets LONGEST: 8 * offset + value_bitpos(val)
+ Variable length initialized to type ULONGEST, expects LONGEST: (type)->length
LOC valops.c:1006
- Function unpack_value_bits_as_long expects arg 3 to be int gets LONGEST: offset
-LOC valops.c:1004
New fresh storage (type struct type *) passed as implicitly temp (not released): value_type(val)
LOC valops.c:1015 (valops.c:1013)
+ Function store_signed_integer expects arg 2 to be int gets LONGEST: length
+LOC valops.c:1015
New fresh storage (type gdb_byte *) passed as implicitly temp (not released): value_contents_raw(val)
LOC valops.c:1022 (valops.c:1019)
- New fresh storage (type struct type *) passed as implicitly temp (not released): value_enclosing_type(val)
+ Variable length initialized to type ULONGEST, expects LONGEST: (check_typedef(enclosing_type))->length
LOC valops.c:1024 (valops.c:1019)
- Variable length initialized to type UINT, expects int: (check_typedef(value_enclosing_type(val)))->length
+ Test expression for if not boolean, type LONGEST: length
LOC valops.c:1026 (valops.c:1021)
- Test expression for if not boolean, type int: length
-LOC valops.c:1023
- Function read_value_memory expects arg 6 to be size_t gets int: length
+ Function read_value_memory expects arg 6 to be size_t gets LONGEST: length
LOC valops.c:1027 (valops.c:1029)
+ Fresh storage enclosing_type not released before scope exit
+ LOC valops.c:1021
+ Fresh storage enclosing_type created
+LOC valops.c:1032
New fresh storage (type struct type *) passed as implicitly temp (not released): value_type(val)
LOC valops.c:1284 (valops.c:1281)
- Operands of <= have incompatible types (UINT, int): (type)->length <= (int)sizeof(LONGEST)
+ Operands of <= have incompatible types (ULONGEST, int): (type)->length <= (int)sizeof(LONGEST)
LOC valops.c:1293 (valops.c:1290)
- Function read_memory expects arg 3 to be ssize_t gets int: changed_len
+ Function read_memory expects arg 3 to be ssize_t gets LONGEST: changed_len
LOC valops.c:1305 (valops.c:1302)
- Function write_memory expects arg 3 to be ssize_t gets int: changed_len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: changed_len
+LOC valops.c:1306
+ Function observer_notify_memory_changed expects arg 2 to be int gets LONGEST: changed_len
LOC valops.c:1354 (valops.c:1351)
- Function get_frame_register_bytes expects arg 3 to be CORE_ADDR gets int: offset
+ Function get_frame_register_bytes expects arg 3 to be CORE_ADDR gets LONGEST: offset
LOC valops.c:1368 (valops.c:1365)
- Function put_frame_register_bytes expects arg 3 to be CORE_ADDR gets int: offset
+ Function put_frame_register_bytes expects arg 3 to be CORE_ADDR gets LONGEST: offset
LOC valops.c:1374 (valops.c:1371)
- Function put_frame_register_bytes expects arg 3 to be CORE_ADDR gets int: value_offset(toval)
+ Function put_frame_register_bytes expects arg 3 to be CORE_ADDR gets LONGEST: value_offset(toval)
LOC valops.c:1375 (valops.c:1372)
- Function put_frame_register_bytes expects arg 4 to be int gets UINT: (type)->length
+ Function put_frame_register_bytes expects arg 4 to be int gets ULONGEST: (type)->length
LOC valops.c:1459 (valops.c:1456)
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC valops.c:1493 (valops.c:1490)
- Function read_value_memory expects arg 6 to be size_t gets UINT: (value_enclosing_type(val))->length
+ Function read_value_memory expects arg 6 to be size_t gets ULONGEST: (value_enclosing_type(val))->length
LOC valops.c:1832 (valops.c:1830)
- Function value_contents_copy expects arg 5 to be int gets UINT: typelength
+ Function value_contents_copy expects arg 2 to be LONGEST gets ULONGEST: idx * typelength
+LOC valops.c:1833
+ Function value_contents_copy expects arg 5 to be LONGEST gets ULONGEST: typelength
LOC valops.c:1842 (valops.c:1839)
- Function value_contents_copy expects arg 5 to be int gets UINT: typelength
+ Function value_contents_copy expects arg 2 to be LONGEST gets ULONGEST: idx * typelength
+LOC valops.c:1842
+ Function value_contents_copy expects arg 5 to be LONGEST gets ULONGEST: typelength
LOC valops.c:1851 (valops.c:1853)
+ Variable highbound initialized to type ULONGEST, expects int: len / (char_type)->length
+LOC valops.c:1856
Function memcpy expects arg 3 to be size_t gets int: len
LOC valops.c:1874 (valops.c:1876)
+ Variable highbound initialized to type ULONGEST, expects int: len / (char_type)->length
+LOC valops.c:1879
Function memcpy expects arg 3 to be size_t gets int: len
LOC valops.c:1893 (valops.c:1890)
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
LOC valops.c:2139 (valops.c:2136)
- Function target_read_memory expects arg 3 to be ssize_t gets UINT: (basetype)->length
+ Function target_read_memory expects arg 3 to be ssize_t gets ULONGEST: (basetype)->length
LOC valops.c:2175 (valops.c:2171)
+ Function update_search_result expects arg 4 to be int gets LONGEST: boffset
+LOC valops.c:2174
Null storage v passed as non-null param: update_search_result (..., v, ...)
LOC valops.c:2289 (valops.c:2286)
- Function C_alloca expects arg 1 to be size_t gets UINT: (baseclass)->length
+ Function C_alloca expects arg 1 to be size_t gets ULONGEST: (baseclass)->length
LOC valops.c:2293 (valops.c:2290)
- Function target_read_memory expects arg 3 to be ssize_t gets UINT: (baseclass)->length
+ Function target_read_memory expects arg 3 to be ssize_t gets ULONGEST: (baseclass)->length
LOC valops.c:3356 (valops.c:3353)
- Left operand of >> may be negative (int): ((((t)->main_type->flds_bnds.fields[i]).loc.bitpos) + 0) >> 3
+ Left operand of >> may be negative (LONGEST): ((((t)->main_type->flds_bnds.fields[i]).loc.bitpos) + 0) >> 3
LOC valops.c:3825 (valops.c:3821)
- Function value_contents_copy expects arg 4 to be int gets LONGEST: offset
-LOC valops.c:3822
- Function value_contents_copy expects arg 5 to be int gets UINT: (slice_type)->length
-LOC valops.c:3827
- Function set_value_offset expects arg 2 to be int gets LONGEST: value_offset(array) + offset
+ Function value_contents_copy expects arg 5 to be LONGEST gets ULONGEST: (slice_type)->length
LOC valops.c:3854 (valops.c:3851)
- Function memcpy expects arg 3 to be size_t gets UINT: (real_type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (real_type)->length
LOC valops.c:3856 (valops.c:3853)
- Function memcpy expects arg 3 to be size_t gets UINT: (real_type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (real_type)->length
LOC valops.c:3874 (valops.c:3871)
- Function memcpy expects arg 3 to be size_t gets UINT: (val_real_type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (val_real_type)->length
LOC valops.c:3877 (valops.c:3874)
- Function memcpy expects arg 3 to be size_t gets UINT: (val_real_type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (val_real_type)->length
LOC valprint.c:848
- Operands of > have incompatible types (UINT, size_t): (type)->length > sizeof(LONGEST)
+ Operands of > have incompatible types (ULONGEST, size_t): (type)->length > sizeof(LONGEST)
LOC valprint.c:1024 (valprint.c:1035)
+ Variable len initialized to type ULONGEST, expects UINT: (type)->length
+LOC valprint.c:1035
Test expression for if not boolean, type int: floatformat_is_negative(fmt, valaddr)
LOC valprint.c:1096 (valprint.c:1098)
+ Variable len initialized to type ULONGEST, expects UINT: (type)->length
+LOC valprint.c:1098
Function decimal_to_string expects arg 2 to be int gets UINT: len
LOC valprint.c:1607 (valprint.c:1611)
+ Operands of < have incompatible types (UINT, ULONGEST): i < len
+LOC valprint.c:1611
Test expression for if not boolean, type int: options->prettyprint_arrays
LOC valprint.c:1631 (valprint.c:1637)
- Function value_available_contents_eq expects arg 5 to be int gets UINT: eltlen
+ Operands of < have incompatible types (UINT, ULONGEST): rep1 < len
+LOC valprint.c:1637
+ Function value_available_contents_eq expects arg 5 to be LONGEST gets ULONGEST: eltlen
+LOC valprint.c:1666
+ Operands of < have incompatible types (UINT, ULONGEST): i < len
valprint.c: (in function partial_memory_read)
LOC valprint.c:1979
- Function C_alloca expects arg 1 to be size_t gets UINT: (type)->length
+ Function C_alloca expects arg 1 to be size_t gets ULONGEST: (type)->length
LOC valprint.c:1982
- Function make_wchar_iterator expects arg 2 to be size_t gets UINT: (type)->length
+ Function make_wchar_iterator expects arg 2 to be size_t gets ULONGEST: (type)->length
LOC valprint.c:1983
- Function make_wchar_iterator expects arg 4 to be size_t gets UINT: (type)->length
+ Function make_wchar_iterator expects arg 4 to be size_t gets ULONGEST: (type)->length
LOC valprint.c:2023
- Function print_wchar expects arg 4 to be int gets UINT: (type)->length
+ Function print_wchar expects arg 4 to be int gets ULONGEST: (type)->length
LOC valprint.c:2030
- Function print_wchar expects arg 4 to be int gets UINT: (type)->length
+ Function print_wchar expects arg 4 to be int gets ULONGEST: (type)->length
LOC valprint.c:2071
- Variable width initialized to type UINT, expects int: (type)->length
+ Variable width initialized to type ULONGEST, expects int: (type)->length
LOC valprint.c:2079
- Operands of == have incompatible types (UINT, int): length == -1
+ Operands of == have incompatible types (ULONGEST, int): length == -1
LOC valprint.c:2109
- Function make_wchar_iterator expects arg 2 to be size_t gets UINT: length * width
+ Function make_wchar_iterator expects arg 2 to be size_t gets ULONGEST: length * width
LOC valprint.c:2313
- Variable width initialized to type UINT, expects int: (elttype)->length
+ Variable width initialized to type ULONGEST, expects int: (elttype)->length
LOC valprint.c:2366
- Function expects arg 4 to be UINT gets int: bytes_read / width
+ Function expects arg 4 to be ULONGEST gets int: bytes_read / width
LOC value.c:449 (value.c:447)
- Assignment of UINT to int: i = (VEC_range_s_lower_bound(value->unavailable, &newr, range_lessthan, "/home/siddhesh/src/upstream/gdb-sources/gdb.git/gdb/value.c", 447))
+ Assignment of UINT to int: i = (VEC_range_s_lower_bound(value->unavailable, &newr, range_lessthan, "/home/siddhesh/src/upstream/gdb-sources/gdb.git/gdb/value.c", 449))
LOC value.c:568 (value.c:566)
- Function memcmp expects arg 3 to be size_t gets int: length
+ Function memcmp expects arg 3 to be size_t gets LONGEST: length
LOC value.c:697 (value.c:695)
- Function xzalloc expects arg 1 to be size_t gets UINT: (val->enclosing_type)->length
+ Function xzalloc expects arg 1 to be size_t gets ULONGEST: (val->enclosing_type)->length
value.c: (in function allocate_repeat_value)
LOC value.c:949 (value.c:946)
- Function memcpy expects arg 3 to be size_t gets int: length
+ Function memcpy expects arg 3 to be size_t gets LONGEST: length
LOC value.c:962 (value.c:958)
- Function mark_value_bytes_unavailable expects arg 2 to be int gets ULONGEST: dst_offset + (l - src_offset)
-LOC value.c:959
- Function mark_value_bytes_unavailable expects arg 3 to be int gets ULONGEST: h - l
+ Function mark_value_bytes_unavailable expects arg 3 to be LONGEST gets ULONGEST: h - l
value.c: (in function value_contents_copy)
LOC value.c:1047 (value.c:1044)
- Function memcmp expects arg 3 to be size_t gets int: len
+ Function memcmp expects arg 3 to be size_t gets LONGEST: len
LOC value.c:1402 (value.c:1399)
- Function memcpy expects arg 3 to be size_t gets UINT: (value_enclosing_type(arg))->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (value_enclosing_type(arg))->length
LOC value.c:1430 (value.c:1427)
- Function memcpy expects arg 3 to be size_t gets UINT: (enc_type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (enc_type)->length
LOC value.c:1957 (value.c:1954)
- Function memcpy expects arg 3 to be size_t gets UINT: (value_type(newval))->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (value_type(newval))->length
LOC value.c:2421 (value.c:2418)
- Variable len initialized to type UINT, expects int: (type)->length
+ Variable len initialized to type ULONGEST, expects int: (type)->length
LOC value.c:2477 (value.c:2474)
- Assignment of UINT to int: len = (type)->length
+ Assignment of ULONGEST to int: len = (type)->length
LOC value.c:2600 (value.c:2597)
- Function xrealloc expects arg 2 to be size_t gets UINT: (new_encl_type)->length
+ Function xrealloc expects arg 2 to be size_t gets ULONGEST: (new_encl_type)->length
LOC value.c:2647 (value.c:2644)
- Operands of <= have incompatible types (UINT, int): (type)->length <= (int)sizeof(LONGEST)
+ Operands of <= have incompatible types (ULONGEST, int): (type)->length <= (int)sizeof(LONGEST)
+LOC value.c:2648
+ Assignment of LONGEST to int: v->bitpos = bitpos % container_bitsize
+LOC value.c:2650
+ Assignment of LONGEST to int: v->bitpos = bitpos % 8
LOC value.c:2816 (value.c:2815)
- Assignment of UINT to int: bytes_read = (field_type)->length
+ Assignment of LONGEST to int: bytes_read = ((bitpos % 8) + bitsize + 7) / 8
+LOC value.c:2818
+ Assignment of ULONGEST to int: bytes_read = (field_type)->length
LOC value.c:2833
+ Assignment of LONGEST to int: lsbcount = (bytes_read * 8 - bitpos % 8 - bitsize)
+LOC value.c:2835
+ Assignment of LONGEST to int: lsbcount = (bitpos % 8)
+LOC value.c:2836
Right operand of >>= may be negative (int): val >>= lsbcount
value.c: (in function modify_field)
LOC value.c:3007
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: bytesize
+LOC value.c:3010
New fresh storage (type struct gdbarch *) passed as implicitly temp (not released): get_type_arch(type)
LOC value.c:3013 (value.c:3010)
- Right operand of << may be negative (int): mask << bitpos
+ Right operand of << may be negative (LONGEST): mask << bitpos
LOC value.c:3014 (value.c:3011)
- Right operand of << may be negative (int): fieldval << bitpos
+ Right operand of << may be negative (LONGEST): fieldval << bitpos
+LOC value.c:3016
+ Function store_unsigned_integer expects arg 2 to be int gets LONGEST: bytesize
value.c: (in function pack_long)
LOC value.c:3028 (value.c:3025)
- Assignment of UINT to int: len = (type)->length
+ Assignment of ULONGEST to int: len = (type)->length
LOC value.c:3063 (value.c:3060)
- Assignment of UINT to int: len = (type)->length
+ Assignment of ULONGEST to int: len = (type)->length
LOC value.c:3144 (value.c:3141)
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
value.c: (in function value_from_contents)
LOC value.c:3160 (value.c:3157)
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
value.c: (in function value_from_double)
LOC value.c:3186 (value.c:3183)
- Function memcpy expects arg 3 to be size_t gets UINT: (type)->length
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: (type)->length
value.c: (in function value_from_history_ref)
LOC vax-tdep.c:132
- Function write_memory expects arg 3 to be ssize_t gets int: len
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC vax-tdep.c:227
- Function read_memory expects arg 3 to be ssize_t gets int: len
+ Function read_memory expects arg 3 to be ssize_t gets LONGEST: len
LOC vax-tdep.c:239
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
LOC vax-tdep.c:244
- Function memcpy expects arg 3 to be size_t gets int: len
+ Function memcpy expects arg 3 to be size_t gets LONGEST: len
+LOC xstormy16-tdep.c:287
+ Assignment of LONGEST to int: slacklen = typelen & 1
LOC xstormy16-tdep.c:288 (xstormy16-tdep.c:285)
- Function C_alloca expects arg 1 to be size_t gets int: typelen + slacklen
+ Function C_alloca expects arg 1 to be size_t gets LONGEST: typelen + slacklen
LOC xstormy16-tdep.c:289 (xstormy16-tdep.c:286)
- Function memcpy expects arg 3 to be size_t gets int: typelen
+ Function memcpy expects arg 3 to be size_t gets LONGEST: typelen
LOC xstormy16-tdep.c:293 (xstormy16-tdep.c:290)
- Function write_memory expects arg 3 to be ssize_t gets int: typelen + slacklen
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: typelen + slacklen
xstormy16-tdep.c: (in function xstormy16_alloc_frame_cache)
LOC xtensa-tdep.c:1621 (xtensa-tdep.c:1625)
+ Assignment of LONGEST to int: offset = 4 - len
+LOC xtensa-tdep.c:1626
+ Function regcache_raw_read_part expects arg 4 to be int gets LONGEST: len
+LOC xtensa-tdep.c:1626
Return value (type enum register_status) ignored: regcache_raw_rea...
LOC xtensa-tdep.c:1671 (xtensa-tdep.c:1675)
+ Assignment of LONGEST to int: offset = 4 - len
+LOC xtensa-tdep.c:1676
Function regcache_raw_write_part expects arg 2 to be int gets UINT: areg
LOC xtensa-tdep.c:1676 (xtensa-tdep.c:1677)
+ Function regcache_raw_write_part expects arg 4 to be int gets LONGEST: len
+LOC xtensa-tdep.c:1678
Function regcache_raw_write expects arg 2 to be int gets UINT: areg
LOC xtensa-tdep.c:1785 (xtensa-tdep.c:1795)
+ Fresh storage arg_type_len_s not released before scope exit
+ LOC xtensa-tdep.c:1767
+ Fresh storage arg_type_len_s created
+LOC xtensa-tdep.c:1797
Test expression for if not boolean, type int: struct_return
LOC xtensa-tdep.c:1822 (xtensa-tdep.c:1820)
- Assignment of UINT to int: info->align = (arg_type)->length
+ Assignment of ULONGEST to int: info->align = (arg_type)->length
LOC xtensa-tdep.c:1830 (xtensa-tdep.c:1828)
- Assignment of UINT to int: info->align = (builtin_type(gdbarch)->builtin_double)->length
+ Assignment of ULONGEST to int: info->align = (builtin_type(gdbarch)->builtin_double)->length
LOC xtensa-tdep.c:1832 (xtensa-tdep.c:1830)
- Assignment of UINT to int: info->align = (builtin_type(gdbarch)->builtin_long)->length
+ Assignment of ULONGEST to int: info->align = (builtin_type(gdbarch)->builtin_long)->length
LOC xtensa-tdep.c:1837 (xtensa-tdep.c:1835)
- Assignment of UINT to int: info->align = (builtin_type(gdbarch)->builtin_long)->length
+ Assignment of ULONGEST to int: info->align = (builtin_type(gdbarch)->builtin_long)->length
+LOC xtensa-tdep.c:1856
+ Assignment of LONGEST to int: info->u.regno = (gdbarch_tdep(gdbarch)->call_abi == CallAbiCall0Only ? (gdbarch_tdep(gdbarch)->a0_base + 2) : (gdbarch_tdep(gdbarch)->a0_base + 6)) + size / 4
LOC xtensa-tdep.c:1886 (xtensa-tdep.c:1895)
- Function write_memory expects arg 3 to be ssize_t gets int: info->length
+ Variable n initialized to type LONGEST, expects int: info->length
+LOC xtensa-tdep.c:1897
+ Function write_memory expects arg 3 to be ssize_t gets LONGEST: info->length
+LOC xtensa-tdep.c:1902
+ Variable n initialized to type LONGEST, expects int: info->length