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

Siddhesh Poyarekar
2012-06-11T18:33:49Z

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

On Mon, 11 Jun 2012 14:59:33 +0200, Jan wrote:
> > Please let me know if any of the above assumptions or wrong or if
> > there are any other cases I can eliminate.
>
> I agree with these assumptions.
>
>

Here's where I'm at right now. I modified the splint command to look
like the following:

rm -rf splint/
mkdir -p splint/bits
touch splint/bits/confname.h
for i in `cat files`; do
mkdir -p splint/`dirname $i`
splint +posixlib +gnuextensions -linelen 999 -hints -showcolumn
\ -Isplint -exportlocal -DTUI -I. \
-Icommon -I../include -I../bfd -I../libdecnumber
-I../opcodes \ -I.. -I/usr/include/python2.7 $i &>splint/$i.out
done

and used the rest of the commands as is:

find splint-clean/ -type f|sort|xargs cat|perl -lpe
's/^(\s*)(\S*?\.[ch]:\d+):/$1LOC $2\n/' >splint-clean.out find
splint-bitpos/ -type f|sort|xargs cat|perl -lpe
's/^(\s*)(\S*?\.[ch]:\d+):/$1LOC $2\n/'
>splint-bitpos.out ./locdiff splint-clean.out splint-bitpos.out

Once I got the locdiff.out, the major improvement was that each warning
has a specific pattern as I mentioned above, which meant that I could
do some further processing to eliminate some of the more obvious
spurious warnings. It also had the effect of reducing the output size
to about 4200 lines.

Then I wrote a script (attached) to reduce this further based on the
following rules:

1) The store_unsigned_integer, extract_unsigned_integer and other
related functions can always safely accept int as argument 2 since the
type length to be passed in it must be a primitive integral type. So we
can ignore all entries that look like:

LOC
- Function store_unsigned_integer expects arg 2 to be int...
+ Function store_unsigned_integer expects arg 2 to be int...

1) Lines of the following format:
LOC
-<old>
+<new>

for type incompatibilities are processed to get the old warning and
new warning and then deduce if we have caused a regression due to the
change. The deducion is based on the type assignment warnings before
and after. The basic rule to deduce safety of the change is to ensure
that the target of the assignment is large enough for the source after
the change.

After running this script the changes to review have come to approx
2500 lines (also attached). Does this look OK? If it does, then I can do
a step-by-step review of these changes and post them.

Regards,
Siddhesh

[-- Attachment #2: process-locdiff --]
[-- Type: application/octet-stream, Size: 5883 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.
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 (/^ 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, $2;
push @from, $3;
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;
}
}

# 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: differ --]
[-- Type: application/octet-stream, Size: 146394 bytes --]

--- /tmp/locdiff.17367.a 2012-06-11 15:25:43.804318482 +0530
+++ /tmp/locdiff.17367.b 2012-06-11 15:25:44.240318492 +0530
@@ -1,367304 +1,367623 @@
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:6449 (ada-lang.c:6444)
+ Function ada_value_primitive_packed_val expects arg 4 to be int gets LONGEST: bit_pos % 8
+LOC ada-lang.c:6447
New fresh storage (type gdb_byte *) passed as implicitly temp (not released): value_contents(arg1)
LOC ada-lang.c:6507
+ Assignment of LONGEST to int: *bit_offset_p = bit_pos % 8
+LOC ada-lang.c:6510
Fresh storage type not released before return
LOC ada-lang.c:6478 (ada-lang.c:6475)
Fresh storage type created
LOC ada-lang.c:7448 (ada-lang.c:7445)
- 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:7447
- 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:7542 (ada-lang.c:7539)
- 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:7542
- 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:7545 (ada-lang.c:7546)
- 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:7585 (ada-lang.c:7582)
- Assignment of UINT to int: fld_bit_len = ((((rtype)->main_type->flds_bnds.fields[variant_field]).type))->length * 8
-LOC ada-lang.c:7586
- Assignment of LONGEST to int: bit_len = off + fld_bit_len
+ Assignment of ULONGEST to LONGEST: fld_bit_len = ((((rtype)->main_type->flds_bnds.fields[variant_field]).type))->length * 8
LOC ada-lang.c:7604 (ada-lang.c:7601)
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("Invalid type size for `%s' detected: %d.")
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("Invalid type size for `%s' detected: %s.")
LOC ada-lang.c:7607 (ada-lang.c:7604)
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("Invalid type size for <unnamed> detected: %d.")
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("Invalid type size for <unnamed> detected: %s.")
LOC ada-lang.c:7945 (ada-lang.c:7942)
- 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:7951 (ada-lang.c:7947)
- Operands of < have incompatible types (UINT, int): (result)->length * 8 < len * elt_bitsize
+ Operands of < have incompatible types (ULONGEST, LONGEST): (result)->length * 8 < len * elt_bitsize
LOC ada-lang.c:8017 (ada-lang.c:8013)
- Operands of != have incompatible types (UINT, LONGEST): (fixed_record_type)->length != size
+ Operands of != have incompatible types (ULONGEST, LONGEST): (fixed_record_type)->length != size
LOC ada-lang.c:8757 (ada-lang.c:8753)
- 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:8812 (ada-lang.c:8808)
- Function ada_index_struct_field expects arg 1 to be int gets LONGEST: index
-LOC ada-lang.c:8808
New fresh storage (type struct type *) passed as implicitly temp (not released): value_type(lhs)
LOC memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
LOC ada-typeprint.c:818
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("<%d-byte integer>")
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("<%s-byte integer>")
LOC ada-typeprint.c:840
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("<%d-byte float>")
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("<%s-byte float>")
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:628
- Operands of < have incompatible types (int, UINT): temp_len < len
+ Operands of < have incompatible types (LONGEST, ULONGEST): temp_len < len
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 progspace.h:37
File static function VEC_so_list_ptr_safe_insert declared but not used
LOC progspace.h:37
Definition of VEC_so_list_ptr_safe_insert
+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:476
Fresh storage gdbarch created
alpha-tdep.c: (in function alpha_store_return_value)
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
LOC linespec.h:54
File static function VEC_linespec_sals_safe_insert declared but not used
LOC linespec.h:54
Definition of VEC_linespec_sals_safe_insert
LOC amd64-tdep.c:489
- Variable bitsize initialized to type UINT, expects int: (((type)->main_type->flds_bnds.fields[i]).bitsize)
+ Variable bitsize initialized to type UINT, expects LONGEST: (((type)->main_type->flds_bnds.fields[i]).bitsize)
amd64-tdep.c: (in function amd64_return_value)
LOC amd64-tdep.c:634
- 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:697
+ Function regcache_raw_read_part expects arg 4 to be int gets LONGEST: ((len) < (8) ? (len) : (8))
+LOC amd64-tdep.c:697
Return value (type enum register_status) ignored: regcache_raw_rea...
LOC amd64-tdep.c:700 (amd64-tdep.c:704)
+ Function regcache_raw_write_part expects arg 4 to be int gets LONGEST: ((len) < (8) ? (len) : (8))
+LOC amd64-tdep.c:704
Fresh storage tdep not released before return
LOC amd64-tdep.c:601
Fresh storage tdep created
LOC amd64-tdep.c:823
- 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:844
- 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:2591
- 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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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
LOC arm-tdep.c:2144
File static function VEC_arm_exidx_entry_s_safe_insert declared but not used
LOC arm-tdep.c:2144
Definition of VEC_arm_exidx_entry_s_safe_insert
avr-tdep.c: (in function avr_pointer_to_address)
LOC avr-tdep.c:931
- Operands of < have incompatible types (int, UINT): i < (valtype)->length
+ Operands of < have incompatible types (LONGEST, ULONGEST): i < (valtype)->length
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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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: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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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:2113 (breakpoint.c:2119)
+ Assignment of LONGEST to int: bl->target_info.length = bl->length
+LOC breakpoint.c:2120
Test expression for if not boolean, type int: is_breakpoint(bl->owner)
LOC breakpoint.c:4334 (breakpoint.c:4331)
+ Function expects arg 4 to be int gets LONGEST: loc->length
+LOC breakpoint.c:4332
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:6309 (breakpoint.c:6306)
- 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:6307
+ 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:9423 (breakpoint.c:9422)
Return value (type int) ignored: create_breakpoin...
+breakpoint.c: (in function breakpoint_hit_ranged_breakpoint)
+LOC breakpoint.c:9450
+ 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:15496 (breakpoint.c:15495)
- 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 breakpoint.c:7511 (breakpoint.c:7510)
File static function VEC_int_safe_insert declared but not used
LOC breakpoint.c:7511 (breakpoint.c:7510)
Definition of VEC_int_safe_insert
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:685
- Operands of < have incompatible types (int, UINT): i < (type)->length
+ Operands of < have incompatible types (LONGEST, ULONGEST): i < (type)->length
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:556 (cp-valprint.c:555)
- Operands of >= have incompatible types (int, UINT): (boffset + offset) >= (real_type)->length
+ Operands of >= have incompatible types (LONGEST, ULONGEST): (boffset + offset) >= (real_type)->length
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 gdb_vecs.h:45
File static function VEC_probe_p_safe_insert declared but not used
LOC gdb_vecs.h:45
Definition of VEC_probe_p_safe_insert
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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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:801
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("Unrecognized %d-bit floating-point type.")
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("Unrecognized %s-bit floating-point type.")
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:1245
- 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:1461 (dwarf2loc.c:1468)
+ Assignment of ULONGEST to UINT: source_offset_bits = source_offset % 8
+LOC dwarf2loc.c:1463
+ Assignment of ULONGEST to UINT: dest_avail = 8 - dest_offset_bits % 8
+LOC dwarf2loc.c:1466
+ Operands of < have incompatible types (UINT, ULONGEST): dest_avail < bit_count
+LOC dwarf2loc.c:1468
Function extract_bits expects arg 3 to be int gets UINT: dest_avail
LOC dwarf2loc.c:1470
+ Function insert_bits expects arg 3 to be UINT gets ULONGEST: dest_offset_bits
+LOC dwarf2loc.c:1470
Function insert_bits expects arg 4 to be int gets UINT: dest_avail
LOC dwarf2loc.c:1489
- 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:1491
- 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:1491
+ Function insert_bits expects arg 4 to be int gets ULONGEST: bit_count
dwarf2loc.c: (in function read_pieced_value)
LOC dwarf2loc.c:1524
- Assignment of int to size_t: type_len = value_bitsize(v)
+ Assignment of int to ULONGEST: type_len = value_bitsize(v)
LOC dwarf2loc.c:1529 (dwarf2loc.c:1527)
- Assignment of UINT to size_t: type_len = 8 * (value_type(v))->length
+ Operands of < have incompatible types (LONGEST, ULONGEST): offset < type_len
LOC dwarf2loc.c:1549 (dwarf2loc.c:1529)
- Operands of < have incompatible types (LONGEST, size_t): offset < type_len
+ Assignment of ULONGEST to LONGEST: source_offset_bits = bits_to_skip
LOC dwarf2loc.c:1561 (dwarf2loc.c:1538)
- Assignment of ULONGEST to size_t: this_size_bits = p->size
+ Operands of < have incompatible types (size_t, ULONGEST): buffer_size < this_size
LOC dwarf2loc.c:1563 (dwarf2loc.c:1539)
- Operands of >= have incompatible types (ULONGEST, size_t): bits_to_skip >= this_size_bits
-LOC dwarf2loc.c:1549
- Assignment of ULONGEST to LONGEST: source_offset_bits = bits_to_skip
+ Assignment of ULONGEST to size_t: buffer_size = this_size
LOC dwarf2loc.c:1578
- 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:1581
- 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:1592
- 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:1596 (dwarf2loc.c:1598)
+ Function memset expects arg 3 to be size_t gets ULONGEST: this_size
+LOC dwarf2loc.c:1598
Test expression for if not boolean, type int: optim
LOC dwarf2loc.c:1601
- Function mark_value_bytes_unavailable expects arg 2 to be int gets LONGEST: offset
-LOC dwarf2loc.c:1601
- 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:1616
+ Function read_value_memory expects arg 6 to be size_t gets ULONGEST: this_size
+LOC dwarf2loc.c:1616
Null storage buffer passed as non-null param: read_value_memory (..., buffer, ...)
LOC dwarf2loc.c:1507
Storage buffer becomes null
LOC dwarf2loc.c:1621 (dwarf2loc.c:1623)
+ Variable n initialized to type ULONGEST, expects size_t: this_size
+LOC dwarf2loc.c:1623
Operands of > have incompatible types (size_t, LONGEST): n > c->addr_size - source_offset
LOC dwarf2loc.c:1642 (dwarf2loc.c:1644)
+ Variable n initialized to type ULONGEST, expects size_t: this_size
+LOC dwarf2loc.c:1644
Operands of > have incompatible types (size_t, ULONGEST): n > p->v.literal.length - source_offset
LOC dwarf2loc.c:1669
- Function copy_bitwise expects arg 4 to be UINT gets LONGEST: source_offset_bits % 8
-LOC dwarf2loc.c:1670
- 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:1708
- Assignment of int to size_t: type_len = value_bitsize(to)
-LOC dwarf2loc.c:1711
- 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:1713
- Operands of < have incompatible types (LONGEST, size_t): offset < type_len
+ Operands of < have incompatible types (LONGEST, ULONGEST): offset < type_len
LOC dwarf2loc.c:1731 (dwarf2loc.c:1721)
- 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:1752 (dwarf2loc.c:1722)
- 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:1754 (dwarf2loc.c:1731)
- Assignment of ULONGEST to LONGEST: dest_offset_bits = bits_to_skip
+ Assignment of ULONGEST to size_t: buffer_size = this_size
LOC dwarf2loc.c:1770
- 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:1772
- 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:1781
- 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:1794
- Function copy_bitwise expects arg 2 to be UINT gets LONGEST: dest_offset_bits
-LOC dwarf2loc.c:1795
- 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:1795 (dwarf2loc.c:1796)
- 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:1801
- 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:1818
- Function copy_bitwise expects arg 2 to be UINT gets LONGEST: dest_offset_bits
-LOC dwarf2loc.c:1819
- 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:1819 (dwarf2loc.c:1820)
- 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:1825
- 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:1867
- 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:1967 (dwarf2loc.c:1966)
- 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:2155 (dwarf2loc.c:2153)
- Function set_value_offset expects arg 2 to be int gets LONGEST: byte_offset
-LOC dwarf2loc.c:2154
Fresh storage c not released before scope exit
LOC dwarf2loc.c:2147 (dwarf2loc.c:2146)
Fresh storage c created
LOC dwarf2loc.c:2198 (dwarf2loc.c:2195)
- Variable n initialized to type UINT, expects size_t: (value_type(value))->length
-LOC dwarf2loc.c:2197
- 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:2221 (dwarf2loc.c:2213)
- Operands of > have incompatible types (size_t, UINT): n > (type)->length
-LOC dwarf2loc.c:2219
- Assignment of UINT to size_t: n = (type)->length
-LOC dwarf2loc.c:2220
Fresh storage objfile_gdbarch not released before scope exit
LOC dwarf2loc.c:2216 (dwarf2loc.c:2215)
Fresh storage objfile_gdbarch created
LOC dwarf2loc.c:2222
+ Function memcpy expects arg 3 to be size_t gets ULONGEST: n
+LOC dwarf2loc.c:2223
Fresh storage value not released before scope exit
LOC dwarf2loc.c:2193 (dwarf2loc.c:2192)
Fresh storage value created
LOC dwarf2loc.c:2242 (dwarf2loc.c:2241)
- 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:2248 (dwarf2loc.c:2247)
- Assignment of UINT to size_t: n = (type)->length
+ Assignment of ULONGEST to size_t: n = (type)->length
LOC dwarf2read.c:978
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("const value length mismatch for '%s', got %d, expected %d")
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("const value length mismatch for '%s', got %s, expected %s")
dwarf2read.c: (in function dwarf2_section_buffer_overflow_complaint)
LOC dwarf2read.c:6086
- 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:7732 (dwarf2read.c:7733)
+ Assignment of size_t to ULONGEST: dlbaton->size = ((attr)->u.blk)->size
+LOC dwarf2read.c:7733
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:7834 (dwarf2read.c:7831)
- Assignment of UINT to size_t: parameter->value_size = ((attr)->u.blk)->size
-LOC dwarf2read.c:7834
Implicitly only storage parameter->data_value (type gdb_byte *) not released before assignment: parameter->data_value = NULL
LOC dwarf2read.c:7853 (dwarf2read.c:7849)
- Assignment of UINT to size_t: parameter->data_value_size = ((attr)->u.blk)->size
-LOC dwarf2read.c:7853
Fresh storage gdbarch not released before return
LOC dwarf2read.c:7611
Fresh storage gdbarch created
LOC dwarf2read.c:8474 (dwarf2read.c:8473)
- Assignment of LONGEST to int: ((*fp).loc.bitpos) = (offset * bits_per_byte)
-LOC dwarf2read.c:8474
Fresh storage attr (type struct attribute *) not released before assignment: attr = dwarf2_attr(die, DW_AT_bit_offset, cu)
LOC dwarf2read.c:8461
Fresh storage attr created
LOC dwarf2read.c:8495 (dwarf2read.c:8484)
- Assignment of ULONGEST to int: ((*fp).loc.bitpos) = ((((*fp).loc.bitpos) + 0) + ((attr)->u.unsnd))
-LOC dwarf2read.c:8495
Variable bit_offset initialized to type ULONGEST, expects int: ((attr)->u.unsnd)
LOC dwarf2read.c:8584 (dwarf2read.c:8582)
- Assignment of LONGEST to int: ((*fp).loc.bitpos) = (offset * bits_per_byte)
-LOC dwarf2read.c:8584
Implicitly only storage fp->type (type struct type *) not released before assignment: ((*fp).type) = die_type(die, cu)
LOC dwarf2read.c:9133 (dwarf2read.c:9126)
- Assignment of ULONGEST to UINT: (type)->length = ((attr)->u.unsnd)
-LOC dwarf2read.c:9133
Test expression for if not boolean, type int: producer_is_icc(cu)
LOC dwarf2read.c:9421 (dwarf2read.c:9409)
- Assignment of ULONGEST to UINT: (type)->length = ((attr)->u.unsnd)
-LOC dwarf2read.c:9421
Test expression for if not boolean, type int: die_is_declaration(die, cu)
LOC dwarf2read.c:9634 (dwarf2read.c:9631)
- Assignment of ULONGEST to UINT: (type)->length = ((attr)->u.unsnd)
-LOC dwarf2read.c:9634
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:9707 (dwarf2read.c:9705)
- Assignment of ULONGEST to UINT: (set_type)->length = ((attr)->u.unsnd)
-LOC dwarf2read.c:9707
Fresh storage domain_type not released before return
LOC dwarf2read.c:9694
Fresh storage domain_type created
LOC dwarf2read.c:9946
- 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:9958
- 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:10024 (dwarf2read.c:10020)
- Assignment of ULONGEST to UINT: (type)->length = ((attr)->u.unsnd)
-LOC dwarf2read.c:10024
- 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:10536
- 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:10541
- 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:10546
- 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:10579 (dwarf2read.c:10577)
- Assignment of ULONGEST to UINT: (range_type)->length = ((attr)->u.unsnd)
-LOC dwarf2read.c:10579
Return value (type struct type *) ignored: set_die_type(die...
LOC dwarf2read.c:11635 (dwarf2read.c:11637)
+ Assignment of UINT to size_t: blk->size = read_2_bytes(abfd, info_ptr)
+LOC dwarf2read.c:11637
+ Function read_n_bytes expects arg 3 to be UINT gets size_t: blk->size
+LOC dwarf2read.c:11637
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:11643 (dwarf2read.c:11645)
+ Assignment of UINT to size_t: blk->size = read_4_bytes(abfd, info_ptr)
+LOC dwarf2read.c:11645
+ Function read_n_bytes expects arg 3 to be UINT gets size_t: blk->size
+LOC dwarf2read.c:11645
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:11679
- 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:11681
+ Function read_n_bytes expects arg 3 to be UINT gets size_t: blk->size
LOC dwarf2read.c:11687 (dwarf2read.c:11689)
+ Assignment of UINT to size_t: blk->size = read_1_byte(abfd, info_ptr)
+LOC dwarf2read.c:11689
+ Function read_n_bytes expects arg 3 to be UINT gets size_t: blk->size
+LOC dwarf2read.c:11689
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:13244
- 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:13709
- 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:13711
- 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:13744 (dwarf2read.c:13745)
- 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:13745 (dwarf2read.c:13746)
- 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:13746
+ Function dwarf2_const_value_length_mismatch_complaint expects arg 3 to be LONGEST gets ULONGEST: (type)->length
LOC dwarf2read.c:14683 (dwarf2read.c:14691)
+ Function pulongest expects arg 1 to be ULONGEST gets size_t: ((&die->attrs[i])->u.blk)->size
+LOC dwarf2read.c:14687
+ Function pulongest expects arg 1 to be ULONGEST gets size_t: ((&die->attrs[i])->u.blk)->size
+LOC dwarf2read.c:14691
Function hex_string expects arg 1 to be LONGEST gets ULONGEST: ((&die->attrs[i])->u.unsnd)
LOC dwarf2read.c:15064 (dwarf2read.c:15070)
+ Assignment of size_t to ULONGEST: retval.size = ((attr)->u.blk)->size
+LOC dwarf2read.c:15070
Null storage retval.data returned as non-null: retval
LOC dwarf2read.c:15041
Storage retval.data becomes null
LOC dwarf2read.c:15267
- Variable size initialized to type UINT, expects int: blk->size
+ Variable size initialized to type size_t, expects int: blk->size
LOC dwarf2read.c:16526 (dwarf2read.c:16527)
+ Assignment of size_t to ULONGEST: baton->size = ((attr)->u.blk)->size
+LOC dwarf2read.c:16527
Implicitly only storage baton->data (type gdb_byte *) not released before assignment: baton->data = ((attr)->u.blk)->data
LOC dwarf2read.c:333
File static function VEC_delayed_method_info_safe_insert declared but not used
LOC dwarf2read.c:333
Definition of VEC_delayed_method_info_safe_insert
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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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:1142
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("Illegal return value length: %d")
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("Illegal return value length: %s")
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
LOC frv-tdep.c:1347
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("Don't know how to return a %d-byte value.")
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("Don't know how to return a %s-byte value.")
frv-tdep.c: (in function frv_return_value)
LOC memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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:1603
Fresh storage target_type created
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-v2-abi.c:395 (gnu-v2-abi.c:394)
- Test expression for if not boolean, type int: boffset
+ Test expression for if not boolean, type LONGEST: boffset
LOC gdb_vecs.h:45
File static function VEC_probe_p_safe_insert declared but not used
LOC gdb_vecs.h:45
Definition of VEC_probe_p_safe_insert
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:295
Fresh storage gdbarch created
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:429
Fresh storage gdbarch created
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:749
File static function VEC_value_and_voffset_p_safe_insert declared but not used
LOC gnu-v3-abi.c:749
Definition of VEC_value_and_voffset_p_safe_insert
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 go-valprint.c:94
Fresh storage type created
LOC memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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: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: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: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 hppa-tdep.c:2779
File static variable hppa_sigtramp declared but 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
+ Function align_up expects arg 1 to be ULONGEST gets LONGEST: args_space
LOC i386-darwin-tdep.c:202
- Function align_up expects arg 1 to be ULONGEST gets int: args_space
+ Function align_up expects arg 2 to be int gets LONGEST: 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 ../bfd/libbfd.h:768
*** Internal Bug at usymtab.c:930: usymtab_supEntryAux: inconsistent state (lexlevel = 0, modFunction = true) adding: ? __PRETTY_FUNCTION__ [errno: 25]
*** Please report bug to splint-bug@splint.org ***
(attempting to continue, results may be incorrect)
1 internal bugs reported
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 progspace.h:37
File static function VEC_so_list_ptr_safe_insert declared but not used
LOC progspace.h:37
Definition of VEC_so_list_ptr_safe_insert
LOC i386-tdep.c:2379
- 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:2484
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("Cannot extract return value of %d bytes long.")
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("Cannot extract return value of %s bytes long.")
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: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
i386-tdep.c: (in function i386_register_to_value)
LOC memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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 ia64-tdep.c:131
File static variable lr_regnum declared but not used
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:6588
- Operands of != have incompatible types (LONGEST, UINT): transferred != (value_type(v))->length
+ Operands of != have incompatible types (LONGEST, ULONGEST): transferred != (value_type(v))->length
LOC infrun.c:6609
- Operands of != have incompatible types (LONGEST, UINT): transferred != (value_type(fromval))->length
+ Operands of != have incompatible types (LONGEST, ULONGEST): transferred != (value_type(fromval))->length
LOC infrun.c:6680 (infrun.c:6677)
- 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:6683
- Operands of == have incompatible types (LONGEST, size_t): target_read(&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL, siginfo_data, 0, len) == len
+ Operands of == have incompatible types (LONGEST, ULONGEST): target_read(&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL, siginfo_data, 0, len) == len
LOC infrun.c:6737 (infrun.c:6734)
- Variable len initialized to type UINT, expects size_t: (type)->length
-LOC infrun.c:6738
- 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
LOC probe.h:128
File static function VEC_probe_ops_cp_safe_insert declared but not used
LOC probe.h:128
Definition of VEC_probe_ops_cp_safe_insert
iq2000-tdep.c: (in function iq2000_register_name)
+LOC iq2000-tdep.c:513
+ Test expression for conditional not boolean, type LONGEST: len % 4
LOC iq2000-tdep.c:513
- 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: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 (iq2000-tdep.c:740)
- Function memcpy expects arg 3 to be size_t gets int: typelen
+ Assignment of LONGEST to int: slacklen = (4 - (typelen % 4)) % 4
+LOC iq2000-tdep.c:741
+ 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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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 symtab.h:1267
File static function VEC_CORE_ADDR_safe_insert declared but not used
LOC symtab.h:1267
Definition of VEC_CORE_ADDR_safe_insert
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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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:423 (m2-valprint.c:426)
Variable i shadows outer declaration
LOC m2-valprint.c:319 (m2-valprint.c:320)
- Previous definition of i: UINT
+ Previous definition of i: ULONGEST
LOC target.h:1034
File static function VEC_memory_write_request_s_safe_insert declared but not used
LOC target.h:1034
Definition of VEC_memory_write_request_s_safe_insert
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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
+LOC m68hc11-tdep.c:1196
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
LOC m68hc11-tdep.c:1213
- Test expression for if not boolean, type int: len & 1
+ Test expression for if not boolean, type LONGEST: len & 1
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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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
LOC m68k-tdep.c:311
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("Cannot extract return value of %d bytes long.")
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("Cannot extract return value of %s bytes long.")
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 (m68k-tdep.c:360)
- Variable len initialized to type UINT, expects int: (type)->length
+ Function regcache_raw_write_part expects arg 3 to be int gets LONGEST: 8 - len
+LOC m68k-tdep.c:348
+ 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: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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
+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.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
LOC memrange.c:76
- Operands of > have incompatible types (int, ULONGEST): (ra->length) > ((rb->start - ra->start) + rb->length)
+ Operands of > have incompatible types (LONGEST, ULONGEST): (ra->length) > ((rb->start - ra->start) + rb->length)
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: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:1013
Fresh storage rawtype created
LOC mips-tdep.c:4305 (mips-tdep.c:4304)
+ Function extract_signed_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:4304
New fresh storage (type gdb_byte *) passed as implicitly temp (not released): value_contents(arg)
LOC mips-tdep.c:4310 (mips-tdep.c:4311)
+ Function store_signed_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:4311
Function store_signed_integer expects arg 4 to be LONGEST gets CORE_ADDR: make_compact_addr(addr)
LOC mips-tdep.c:4390 (mips-tdep.c:4391)
+ Function extract_signed_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:4391
Test expression for if not boolean, type int: mips_debug
LOC mips-tdep.c:4393 (mips-tdep.c:4407)
+ Function phex expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:4407
Variable odd_sized_struct initialized to type boolean, expects int: (len > regsize && len % regsize != 0)
LOC mips-tdep.c:4415 (mips-tdep.c:4417)
+ Variable partial_len initialized to type LONGEST, expects int: (len < regsize ? len : regsize)
+LOC mips-tdep.c:4417
Test expression for if not boolean, type int: mips_debug
LOC mips-tdep.c:4437 (mips-tdep.c:4440)
- Operands of < have incompatible types (UINT, int): (arg_type)->length < regsize
+ Assignment of LONGEST to int: longword_offset = regsize - len
+LOC mips-tdep.c:4440
+ Operands of < have incompatible types (ULONGEST, int): (arg_type)->length < regsize
+LOC mips-tdep.c:4441
+ Assignment of LONGEST to int: longword_offset = regsize - len
LOC mips-tdep.c:4558
- Operands of < have incompatible types (int, UINT): offset < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): offset < (type)->length
LOC mips-tdep.c:4562
- 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:4563
- Assignment of UINT to int: xfer = (type)->length - offset
+ Assignment of ULONGEST to int: xfer = (type)->length - offset
LOC mips-tdep.c:4592
- Operands of < have incompatible types (UINT, int): (arg_type)->length < offset + MIPS64_REGSIZE
+ Operands of < have incompatible types (ULONGEST, LONGEST): (arg_type)->length < offset + MIPS64_REGSIZE
LOC mips-tdep.c:4930
- 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:4963
- 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:5013
- 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:5029
- Operands of < have incompatible types (int, UINT): offset < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): offset < (type)->length
LOC mips-tdep.c:5033
- 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:5034
- Assignment of UINT to int: xfer = (type)->length - offset
+ Assignment of ULONGEST to int: xfer = (type)->length - offset
LOC mips-tdep.c:5052
- Operands of < have incompatible types (int, UINT): offset < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): offset < (type)->length
LOC mips-tdep.c:5056
- 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:5057
- Assignment of UINT to int: xfer = (type)->length - offset
+ Assignment of ULONGEST to int: xfer = (type)->length - offset
LOC mips-tdep.c:5123 (mips-tdep.c:5121)
- Variable arglen initialized to type UINT, expects int: (arg_type)->length
-LOC mips-tdep.c:5124
Test expression for if not boolean, type int: mips_type_needs_double_align(arg_type)
LOC mips-tdep.c:5124 (mips-tdep.c:5125)
- Function align_up expects arg 1 to be ULONGEST gets int: len
-LOC mips-tdep.c:5125
- 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:5124 (mips-tdep.c:5127)
- 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:5159 (mips-tdep.c:5160)
Variable len shadows outer declaration
LOC mips-tdep.c:5095
- Previous definition of len: int
+ Previous definition of len: LONGEST
LOC mips-tdep.c:5234 (mips-tdep.c:5235)
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5234
Variable regval initialized to type ULONGEST, expects LONGEST: extract_unsigned_integer(val, len, byte_order)
LOC mips-tdep.c:5237 (mips-tdep.c:5240)
+ Function phex expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5239
Function regcache_cooked_write_unsigned expects arg 3 to be ULONGEST gets LONGEST: regval
LOC mips-tdep.c:5245 (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:5277 (mips-tdep.c:5280)
+ Variable partial_len initialized to type LONGEST, expects int: (len < MIPS32_REGSIZE ? len : MIPS32_REGSIZE)
+LOC mips-tdep.c:5279
Test expression for if not boolean, type int: mips_debug
LOC mips-tdep.c:5437 (mips-tdep.c:5438)
- 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:5443 (mips-tdep.c:5444)
- 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:5592 (mips-tdep.c:5593)
- Operands of < have incompatible types (int, UINT): offset < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): offset < (type)->length
LOC mips-tdep.c:5596 (mips-tdep.c:5597)
- 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:5597 (mips-tdep.c:5598)
- Assignment of UINT to int: xfer = (type)->length - offset
+ Assignment of ULONGEST to int: xfer = (type)->length - offset
LOC mips-tdep.c:5652 (mips-tdep.c:5650)
- Variable arglen initialized to type UINT, expects int: (arg_type)->length
-LOC mips-tdep.c:5653
- Function align_up expects arg 1 to be ULONGEST gets int: arglen
-LOC mips-tdep.c:5654
Fresh storage arg_type not released before scope exit
LOC mips-tdep.c:5648 (mips-tdep.c:5649)
Fresh storage arg_type created
LOC mips-tdep.c:5685 (mips-tdep.c:5687)
Variable len shadows outer declaration
LOC mips-tdep.c:5623 (mips-tdep.c:5624)
- Previous definition of len: int
+ Previous definition of len: LONGEST
LOC mips-tdep.c:5701 (mips-tdep.c:5702)
+ Function extract_signed_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5700
New fresh storage (type gdb_byte *) passed as implicitly temp (not released): value_contents(arg)
LOC mips-tdep.c:5704 (mips-tdep.c:5707)
+ Function store_signed_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5705
Function store_signed_integer expects arg 4 to be LONGEST gets CORE_ADDR: make_compact_addr(addr)
LOC mips-tdep.c:5723 (mips-tdep.c:5725)
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5723
Variable regval initialized to type ULONGEST, expects LONGEST: extract_unsigned_integer(val, len, byte_order)
LOC mips-tdep.c:5726 (mips-tdep.c:5729)
+ Function phex expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5727
Function regcache_cooked_write_unsigned expects arg 3 to be ULONGEST gets LONGEST: regval
LOC mips-tdep.c:5730 (mips-tdep.c:5733)
+ Function phex expects arg 2 to be int gets LONGEST: len
+LOC mips-tdep.c:5731
Function regcache_cooked_write_unsigned expects arg 3 to be ULONGEST gets LONGEST: regval
LOC mips-tdep.c:5751 (mips-tdep.c:5755)
+ Variable partial_len initialized to type LONGEST, expects int: (len < MIPS64_REGSIZE ? len : MIPS64_REGSIZE)
+LOC mips-tdep.c:5753
Test expression for if not boolean, type int: mips_debug
LOC mips-tdep.c:5772 (mips-tdep.c:5777)
+ Assignment of LONGEST to int: longword_offset = MIPS64_REGSIZE - len
+LOC mips-tdep.c:5775
Test expression for if not boolean, type int: mips_debug
LOC mips-tdep.c:5778 (mips-tdep.c:5780)
- 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:5902 (mips-tdep.c:5904)
- 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:5908 (mips-tdep.c:5910)
- 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:5920 (mips-tdep.c:5922)
- Operands of < have incompatible types (int, UINT): offset < (type)->length
+ Operands of < have incompatible types (int, ULONGEST): offset < (type)->length
LOC mips-tdep.c:5924 (mips-tdep.c:5926)
- 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:5925 (mips-tdep.c:5927)
- Assignment of UINT to int: xfer = (type)->length - offset
+ Assignment of ULONGEST to int: xfer = (type)->length - offset
LOC ../include/opcode/mips.h:711
File static variable mips_isa_table declared but not used
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 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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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 (mt-tdep.c:838)
- Function write_memory expects arg 1 to be CORE_ADDR gets int: stack_dest
+ Function memcpy expects arg 3 to be size_t gets LONGEST: typelen
LOC mt-tdep.c:838
- Function write_memory expects arg 3 to be ssize_t gets int: typelen
+ 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 LONGEST: typelen
+LOC mt-tdep.c:851
+ Assignment of LONGEST to int: slacklen = (4 - (typelen % 4)) % 4
LOC mt-tdep.c:852
- 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 mt-tdep.c:853
- 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 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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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 symtab.h:1267
File static function VEC_CORE_ADDR_safe_insert declared but not used
LOC symtab.h:1267
Definition of VEC_CORE_ADDR_safe_insert
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
LOC symtab.h:1267
File static function VEC_CORE_ADDR_safe_insert declared but not used
LOC symtab.h:1267
Definition of VEC_CORE_ADDR_safe_insert
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-linux-nat.c:1398
File static function VEC_thread_points_p_safe_insert declared but not used
LOC ppc-linux-nat.c:1398
Definition of VEC_thread_points_p_safe_insert
LOC ppc-sysv-tdep.c:162
- 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:162
+ Assignment of ULONGEST to LONGEST: argoffset = align_up(argoffset, 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
+ Function align_up expects arg 2 to be int gets LONGEST: 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: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: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: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: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
+ 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 UINT: (valtype)->length
+ 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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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:376
Fresh storage gdbarch created
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:376
Fresh storage gdbarch created
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:376
Fresh storage gdbarch created
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: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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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-typeprint.c:478
Fresh storage type created
LOC memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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
+ Function read_memory expects arg 3 to be ssize_t gets LONGEST: length_size
LOC p-valprint.c:214 (p-valprint.c:212)
- Function read_memory expects arg 3 to be ssize_t gets int: length_size
+ 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:799 (p-valprint.c:798)
- Operands of >= have incompatible types (int, UINT): boffset >= (type)->length
+ Operands of >= have incompatible types (LONGEST, ULONGEST): boffset >= (type)->length
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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
Spec file not found: python.lcl
Cannot open file: python.c
Finished checking --- no code processed
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 progspace.h:37
File static function VEC_so_list_ptr_safe_insert declared but not used
LOC progspace.h:37
Definition of VEC_so_list_ptr_safe_insert
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.c:9136
File static function VEC_remote_g_packet_guess_s_safe_insert declared but not used
LOC remote.c:9136
Definition of VEC_remote_g_packet_guess_s_safe_insert
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)
LOC memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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
LOC breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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: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: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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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: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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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: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: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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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:2667 (tracepoint.c:2665)
- Operands of < have incompatible types (int, UINT): j < ((sym)->type)->length
+ Operands of < have incompatible types (LONGEST, ULONGEST): j < ((sym)->type)->length
LOC tracepoint.c:4685 (tracepoint.c:4680)
- Assignment of unsigned short int to int: r->length = mlen
+ Assignment of unsigned short int to LONGEST: r->length = mlen
LOC v850-tdep.c:837
Variable len shadows outer declaration
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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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: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 target.h:1034
File static function VEC_memory_write_request_s_safe_insert declared but not used
LOC target.h:1034
Definition of VEC_memory_write_request_s_safe_insert
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:1283 (valops.c:1280)
- Operands of < have incompatible types (int, UINT): changed_len < (type)->length
+ Operands of < have incompatible types (LONGEST, ULONGEST): changed_len < (type)->length
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: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:2131 (valops.c:2128)
- Operands of >= have incompatible types (int, UINT): boffset >= (value_enclosing_type(arg1))->length
+ Operands of >= have incompatible types (LONGEST, ULONGEST): boffset >= (value_enclosing_type(arg1))->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:2103 (valops.c:2100)
Storage v becomes null
LOC valops.c:2287 (valops.c:2284)
- Operands of >= have incompatible types (int, UINT): offset >= (type)->length
+ Operands of >= have incompatible types (LONGEST, ULONGEST): offset >= (type)->length
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:3357 (valops.c:3354)
- 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:3826 (valops.c:3822)
- Function value_contents_copy expects arg 4 to be int gets LONGEST: offset
-LOC valops.c:3823
- Function value_contents_copy expects arg 5 to be int gets UINT: (slice_type)->length
-LOC valops.c:3828
- 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:3855 (valops.c:3852)
- 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:3857 (valops.c:3854)
- 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:3875 (valops.c:3872)
- 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:3878 (valops.c:3875)
- 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 memrange.h:38
File static function VEC_mem_range_s_safe_insert declared but not used
LOC memrange.h:38
Definition of VEC_mem_range_s_safe_insert
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: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: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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
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:956 (value.c:953)
- Assignment of int to ULONGEST: l = ((r->offset) > (src_offset) ? (r->offset) : (src_offset))
-LOC value.c:954
- Assignment of int to ULONGEST: h = ((r->offset + r->length) < (src_offset + length) ? (r->offset + r->length) : (src_offset + length))
+ Assignment of LONGEST to ULONGEST: l = ((r->offset) > (src_offset) ? (r->offset) : (src_offset))
LOC value.c:957 (value.c:958)
- Function mark_value_bytes_unavailable expects arg 2 to be int gets ULONGEST: dst_offset + (l - src_offset)
+ Assignment of LONGEST to ULONGEST: h = ((r->offset + r->length) < (src_offset + length) ? (r->offset + r->length) : (src_offset + length))
value.c: (in function value_contents_copy)
LOC value.c:1044 (value.c:1041)
- Operands of != have incompatible types (int, UINT): len != (type2)->length
+ Operands of != have incompatible types (LONGEST, ULONGEST): len != (type2)->length
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:1934 (value.c:1931)
- 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:2454 (value.c:2451)
- Assignment of UINT to int: len = (type)->length
+ Assignment of ULONGEST to int: len = (type)->length
LOC value.c:2577 (value.c:2574)
- 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:2624 (value.c:2621)
- 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:2625
+ Assignment of LONGEST to int: v->bitpos = bitpos % container_bitsize
+LOC value.c:2627
+ Assignment of LONGEST to int: v->bitpos = bitpos % 8
LOC value.c:2793 (value.c:2792)
- 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:2795
+ Assignment of ULONGEST to int: bytes_read = (field_type)->length
LOC value.c:2810
+ Assignment of LONGEST to int: lsbcount = (bytes_read * 8 - bitpos % 8 - bitsize)
+LOC value.c:2812
+ Assignment of LONGEST to int: lsbcount = (bitpos % 8)
+LOC value.c:2813
Right operand of >>= may be negative (int): val >>= lsbcount
value.c: (in function modify_field)
LOC value.c:2984
+ Function extract_unsigned_integer expects arg 2 to be int gets LONGEST: bytesize
+LOC value.c:2987
New fresh storage (type struct gdbarch *) passed as implicitly temp (not released): get_type_arch(type)
LOC value.c:2990 (value.c:2987)
- Right operand of << may be negative (int): mask << bitpos
+ Right operand of << may be negative (LONGEST): mask << bitpos
LOC value.c:2991 (value.c:2988)
- Right operand of << may be negative (int): fieldval << bitpos
+ Right operand of << may be negative (LONGEST): fieldval << bitpos
+LOC value.c:2993
+ Function store_unsigned_integer expects arg 2 to be int gets LONGEST: bytesize
value.c: (in function pack_long)
LOC value.c:3005 (value.c:3002)
- Assignment of UINT to int: len = (type)->length
+ Assignment of ULONGEST to int: len = (type)->length
LOC value.c:3040 (value.c:3037)
- Assignment of UINT to int: len = (type)->length
+ Assignment of ULONGEST to int: len = (type)->length
LOC value.c:3121 (value.c:3118)
- 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:3137 (value.c:3134)
- 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:3163 (value.c:3160)
- 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 value.c:78
File static function VEC_range_s_safe_push declared but not used
LOC value.c:78
Definition of VEC_range_s_safe_push
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 breakpoint.h:829
File static function VEC_breakpoint_p_safe_insert declared but not used
LOC breakpoint.h:829
Definition of VEC_breakpoint_p_safe_insert
LOC xtensa-tdep.c:1601
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("cannot extract return value of %d bytes long")
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("cannot extract return value of %s bytes long")
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:1657 (xtensa-tdep.c:1656)
- New fresh storage (type char *) passed as implicitly temp (not released): gettext("unimplemented for this length: %d")
+ New fresh storage (type char *) passed as implicitly temp (not released): gettext("unimplemented for this length: %s")
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
LOC dwarf2expr.h:335
File static function gdb_skip_leb128 declared but not used
LOC dwarf2expr.h:342
Definition of gdb_skip_leb128