gmane.comp.parsers.sparse

[PATCH] Updated nocast vs bitwise documentation

Shakthi Kannan — 2012-05-10T06:54:28

I have updated the sparse.1 man page including the __bitwise
relevant content, and created Documentation/sparse.txt with the
complete comparison between __nocast vs __bitwise.

Signed-off-by: Shakthi Kannan <shakthimaan< at >gmail.com>
---
 Documentation/sparse.txt |   39 +++++++++++++++++++++++++++++++++++++++
 sparse.1                 |   14 +++++++++++++-
 2 files changed, 52 insertions(+), 1 deletions(-)
 create mode 100644 Documentation/sparse.txt

diff --git a/Documentation/sparse.txt b/Documentation/sparse.txt
new file mode 100644
index 0000000..37e8916
--- /dev/null
+++ b/Documentation/sparse.txt
< at >< at > -0,0 +1,39 < at >< at >
+Sparse
+~~~~~~
+
+__nocast vs __bitwise:
+
+__nocast warns about explicit or implicit casting to different types.
+
+HOWEVER, it doesn't consider two 32-bit integers to be different
+types, so a __nocast 'int' type may be returned as a regular 'int'
+type and then the __nocast is lost.
+
+So "__nocast" on integer types is usually not that powerful. It just
+gets lost too easily. It's more useful

simplify: conservative handling of casts with pointers

Jan Pokorný — 2012-05-08T14:13:44

When the cast is optimized out/target pointer type information lost,
it may be impossible to for backend to recover it (think of
"struct foo *my_new_foo = malloc(sizeof(*my_new_foo))").

Losing such pointer type information can be wider issue (structs and
unions maybe), but this is the most exposed one and the patch tries
to be minimal in this regard and the impact seems to be minimal
too as usually type-correctness is followed.

Annotated demonstration of the change (part of "test-linearize allocate.c",
function allocate):

before:

.L0x7fd091ecb510:
        load.32     %r76 <- 20[%arg1]
        cast.64     %r78 <- (32) %r76
        call.64     %r79 <- blob_alloc, %r78
        br          %r79, .L0x7fd091ecb650, .L0x7fd091ecb600

.L0x7fd091ecb600:
        call        die, "out of memory"
        br          .L0x7fd091ecb650

.L0x7fd091ecb650:
        load.32     %r85 <- 36[%arg1]
        add.32      %r87 <- %r85, %r76
        store.32    %r87 -> 36[%arg1]
        store.64    %r30(blob) -> 0[%r79]
        st

[PATCH] unssa: track use of newly added pseudo

Jan Pokorný — 2012-05-03T14:59:11

Currently, it is a completely "isolated island" from backend
point of view as it also lacks pseudo->def information.

Signed-off-by: Jan Pokorný <pokorny_jan< at >seznam.cz>
---
 unssa.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

diff --git a/unssa.c b/unssa.c
index 3eea9b2..382095d 100644
--- a/unssa.c
+++ b/unssa.c
< at >< at > -55,7 +55,7 < at >< at > static void replace_phi_node(struct instruction *phi)
 track_phi_uses(phi);
 
 phi->opcode = OP_COPY;
-phi->src = tmp;
+use_pseudo(phi, tmp, &phi->src);
 
 // FIXME: free phi->phi_list;
 }

dependency tee from c parser entities downto token

Konrad Eisele — 2012-04-24T09:54:45

Hi, I'd like to extend sparse so that I can preserve a
dependency tree that goes from c parse entities all
the way down to single tokens. There are several places
this can be useful:
  1. If you have :
    "#include <stdio.h> int main() {}"
    and add for instance
    "#include <stdio.h> int main() {FILE *f;}"
    what are the macros and structs that are used for this single "FILE *f;"?
    (With macros and all #ifdef nesting macros dependencies and their dependendies
     and macros in macro arg/body substitutions and also macros in c parse entities
     that FILE (struct _IO_FILE) c-depends on)
  2. If you have a compilation with a fixed options-line, calculate
    a minimal c sourcefile that is "pre pre-processor" that compiles correctly.
    This would save time in compilation, stripping away all unneeded
    macros defines and declarations.
  3. You could also use it to write tools to show the
    dependency tree of macros at a particular location of the source...
    something all c-coders long for (a

Please be informed!

Western Union® — 2012-04-05T06:14:16

Please be informed that you have $250,000.00 to transfer to you as
Compensation.


-----------------------------------------
   "Universidad Autónoma de Yucatán"
http://www.uady.mx/

--
To unsubscribe from this list: send the line "unsubscribe linux-sparse" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Killing off __cond_lock()

Peter Zijlstra — 2012-03-24T16:23:36

Hi all,

So the kernel has this __cond_lock() crap pile, which is implemented
like:

#define __acquire(x)       __context__(x,1)
#define __cond_lock(x,c)   ((c) ? ({ __acquire(x); 1; }) : 0)

Now the problem with this is that people send ugly patches like:

https://lkml.org/lkml/2012/3/24/57
http://www.spinics.net/lists/mm-commits/msg80386.html

That basically wrap an existing function in an inline function just to
use __cond_lock() on the return value.

It would be ever so much nicer if we could declare such functions like:

struct anon_vma *page_lock_anon_vma(struct page *page)
__cond_acquires(RCU) 
__cond_acquires(page_lock_anon_vma(page)->root->lock);

Meaning that if the return value is true (non-zero), it would acquire
that lock/context. One could of course add some shorter means of
referring to the return value, but simply using the function in the
expression should be simple enough.

In order to implement this I guess we need to extend the
__attribute__((context(expr,in,out))) thing. 

Currently in

help needed: document nocast vs bitwise (Was: [PATCH 00/16] mm: prepare for converting vm->vm_flags to 64-bit)

Christopher Li — 2012-03-23T18:17:10

Linus has a very nice write up about __nocast vs __bitwise.

Can any one help to integrate the write up to a patch
against man page sparse.1?

I would much rather hitting the apply button than hacking
documents. But if nobody wants to do it, it would have to
be me then.

Yes, I am a lazy baster :-)

Thanks

Chris

---------- Forwarded message ----------
From: Linus Torvalds <torvalds< at >linux-foundation.org>
Date: Thu, Mar 22, 2012 at 3:08 PM
Subject: Re: [PATCH 00/16] mm: prepare for converting vm->vm_flags to 64-bit
To: Andrew Morton <akpm< at >linux-foundation.org>
Cc: Al Viro <viro< at >zeniv.linux.org.uk>, Konstantin Khlebnikov
<khlebnikov< at >openvz.org>, Minchan Kim <minchan< at >kernel.org>,
"linux-mm< at >kvack.org" <linux-mm< at >kvack.org>,
"linux-kernel< at >vger.kernel.org" <linux-kernel< at >vger.kernel.org>, Hugh
Dickins <hughd< at >google.com>, KOSAKI Motohiro
<kosaki.motohiro< at >jp.fujitsu.com>, Ben Herrenschmidt
<benh< at >kernel.crashing.org>, "linux< at >arm.linux.org.uk"
<linux< at >arm.linux.org.uk>


On Thu, Mar 22, 2012 at 2:41 PM, Andrew Morton
<a

Using c2xml on kernel sources

Shakthi Kannan — 2012-03-20T09:00:18

Hi,

I would like to run c2xml on the Linux kernel sources. Is there a
recommended way of using the tool on kernel code?

I tried running it directly on a source file, but, get the
'header-file "unable to open" error.

  $ c2xml linux-3.0.4/net/ethernet/eth.c

  ../linux-3.0.4/net/ethernet/eth.c:40:11: error: unable to open
'linux/module.h'

I have built sparse from git sources (v0.4.4) on Fedora 15 x86_64.

Appreciate any inputs in this regard.

Thanks!

SK

Patch: add __builtin_stpcpy and __sync_synchronize to builtin functions

Frederic Crozat — 2012-03-15T14:15:43

Hi,

while working on integrating sparse checks in systemd, I noticed some
builtin functions need to be added to sparse list. See attached patch
for the fix.

I've also noted patch from Pekka Enberg
(http://www.spinics.net/lists/linux-sparse/msg02520.html ) is still
needed when running sparse on x86-64. It would be nice to merge it in
git.

MAIL 10.03.2012

Mr. Richard Tang — 2012-03-11T10:05:28

Mail From Tang.

I work with the hang seng Bank Hong Kong.I have a business proposition for you involving a trade in my bank which I know we will be of mutual benefit to both of us, If interested mail me at:tangricad< at >yahoo.co.jp

Regards,
Richard Tang.
--
To unsubscribe from this list: send the line "unsubscribe linux-sparse" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

strings

Benjamin Herrenschmidt — 2012-03-03T10:46:12

Hi folks !

I just noticed, as I was digging into (yet another) unrelated llvm
problem with my code, that sparse-llvm fails to compile something that
has a statement such as:

static char *foo = "Foo !\n";

It pukes in output_data(), where we have initializer non-NULL and
initializer->type is EXPR_STRING. So we hit the default: case which is
an assert(0);

Now a trivial "fix" below doesn't quite work:

diff --git a/sparse-llvm.c b/sparse-llvm.c
index 9226a21..f151939 100644
--- a/sparse-llvm.c
+++ b/sparse-llvm.c
< at >< at > -1181,6 +1181,12 < at >< at > static LLVMValueRef output_data(LLVMModuleRef module, struct symbol *sym)
 initial_value = output_data(module, sym);
 break;
 }
+case EXPR_STRING: {
+const char *s = initializer->string->data;
+
+initial_value = LLVMConstString(strdup(s), strlen(s) + 1, true);
+break;
+}
 default:
 assert(0);
 }

That has two interesting effects. First, if llvm is compiled with asserts,
it pukes claiming that the initializer is of the wrong type. Now that's
odd bec

sparse-llvm: pseudo_to_value: Assertion `sym->ident == ((void *)0)' failed

Benjamin Herrenschmidt — 2012-02-13T07:17:39

Hi folks !

Haven't had a chance to investigate further today (and probably won't)
so I'm shooting this here just in case ;-)

I was tracking down what looks like an LLVM bug with sign extension from
1-bit integers while playing with llvmpipe (gallium llvm backend) and
out of curiosity decided to look at what sparse generated when
sign-extending a bool :-)

So I added to my earlier hello.c some statements to that effect, and
trying to compile it results in:

sparse-llvm.c:311: pseudo_to_value: Assertion `sym->ident == ((void *)0)' failed.

The new hello.c is:

#include <stdio.h>
#include <stdbool.h>

int main(void)
{
        int i;
        double f1,f2;
        bool eq;

        printf("Hello World !\n");

        for (i = 0; i < 10; i ++)
                printf("I can count to %d\n", i);

        printf("f1=");
        scanf("%f",&f1);
        printf("f2=");
        scanf("%f",&f2);

        eq = f1 == f2;

        printf("f1==f2: %d\n", (int)eq);
        return 0;
}

Cheers,
Ben.


--
To unsubscribe from t

[RFC/PATCH 1/2] sparse, llvm: Make function declaration accessible to backend

Pekka Enberg — 2012-02-01T09:55:51

From: Linus Torvalds <torvalds< at >linux-foundation.org>

On Tue, Aug 30, 2011 at 10:43 AM, Jeff Garzik <jeff< at >garzik.org> wrote:

Hmm. Right now we do not have access to the function declaration at
linearize time. We've checked that the arguments match, and we've cast
the arguments to the right types (evaluate.c), so the thinking was
that you just use the arguments as-is.

But if llvm needs the declaration of a function, we'd need to squirrel it away.

Cc: Benjamin Herrenschmidt <benh< at >kernel.crashing.org>
Cc: Christopher Li <sparse< at >chrisli.org>
Cc: Jeff Garzik <jgarzik< at >redhat.com>
Cc: Linus Torvalds <torvalds< at >linux-foundation.org>
[ penberg< at >kernel.org: Fix validation/context.c breakage. ]
Signed-off-by: Pekka Enberg <penberg< at >kernel.org>
---
 linearize.c |    8 ++++++++
 linearize.h |    1 +
 2 files changed, 9 insertions(+), 0 deletions(-)

diff --git a/linearize.c b/linearize.c
index 1899978..7d57474 100644
--- a/linearize.c
+++ b/linearize.c
< at >< at > -1195,6 +1195,7 < at >< at > static pseudo_t linearize_call_expression(struc

[PATCH] evaluate: reject post-ops on void*

Jan Pokorný — 2012-01-22T23:31:21

Following example haven't been linearized correctly:

static void *inc_ptr(void *a) {
return ++a;
}

test-linearize:

<entry-point>
add.32      %r2 <- %arg1, $-1
ret.32      %r2

Apparently, something went wrong with -1 value to be added to the original
pointer.  When void* substituted for int*, the result is as expected
(considering 32b int):

<entry-point>
add.32      %r2 <- %arg1, $4
ret.32      %r2

The proposed patch turns post-ops on void* operand into an error
(taking the same route as with function operand).

When running check with C=2 on my old linux-3.0.6 configuration,
this detected a few occurencies:

drivers/scsi/scsi_proc.c:405:31: error: bad argument type for ++/--
drivers/scsi/scsi_proc.c:413:23: error: bad argument type for ++/--
net/bluetooth/hci_core.c:1545:29: error: bad argument type for ++/--
net/bluetooth/l2cap_core.c:1825:37: error: bad argument type for ++/--
net/bluetooth/bnep/core.c:239:13: error: bad argument type for ++/--
lib/sort.c:25:27: error: bad argument ty

sparse-llvm has been merged

Christopher Li — 2012-01-19T02:00:22

 Pekka's sparse-llvm has been merged at sparse chrisl branch.

http://git.kernel.org/?p=devel/sparse/chrisl/sparse.git;a=summary

The new llvm back end require llvm 3.0.

Chris

Merge branch 'sparse-llvm' of git://github.com/penberg/sparse-llvm.git

    'master' branch of git://github.com/penberg/sparse-llvm.git

        Revert "sparse: Bump up sizeof(_Bool) to 8 bits"
        sparse, llvm: Add test case for <stdbool.h> type
        sparse, llvm: Use LLVMInt1Type() in sym_basetype_type()
        sparse, llvm: Don't fail the build if LLVM is too old
        Merge pull request #6 from jgarzik/hacks
        sparse, llvm: add loop testcase
        sparse, llvm: Fix loops, by properly handling OP_PHI forward references
        sparse, llvm: FP comparison op code generation
        sparse, llvm: Simplify comparison op code generation
        sparse, llvm: More comparison ops code generation
        sparse, llvm: OP_SET_B and OP_SET_A code generation
        sparse, llvm: Pointer cast code generation
        sparse

[PATCH] sparse: Add 'leaf' to ignored attributes.

Ethan Jackson — 2012-01-17T22:47:11

This patch adds the 'leaf' GCC attribute to the list of ignored
attributes.  Glibc uses this attribute causing the following
warnings in userspace projects:

  /usr/include/stdlib.h:514:26: error: attribute '__leaf__': unknown attribute

Signed-off-by: Ethan Jackson <ethan< at >nicira.com>
---
 ident-list.h |    2 ++
 parse.c      |    2 ++
 2 files changed, 4 insertions(+), 0 deletions(-)

diff --git a/ident-list.h b/ident-list.h
index b12d172..35ac6bd 100644
--- a/ident-list.h
+++ b/ident-list.h
< at >< at > -88,6 +88,8 < at >< at > IDENT(dllimport); IDENT(__dllimport__);
 IDENT(dllexport); IDENT(__dllexport__);
 IDENT(restrict); IDENT(__restrict);
 IDENT(artificial); IDENT(__artificial__);
+IDENT(leaf); IDENT(__leaf__);
+
 
 /* Preprocessor idents.  Direct use of __IDENT avoids mentioning the keyword
  * itself by name, preventing these tokens from expanding when compiling
diff --git a/parse.c b/parse.c
index bd42180..f8ade3e 100644
--- a/parse.c
+++ b/parse.c
< at >< at > -519,6 +519,8 < at >< at > const char *ignored_attributes[] = {
 "__format_a

[PATCH 1/3] sparse, llvm: Use LLVMInt1Type() in sym_basetype_type()

Pekka Enberg — 2011-12-21T09:25:26

In preparation for reverting commit 2ded1e7 ("sparse: Bump up sizeof(_Bool) to
8 bits"), teach sym_basetype_type() about LLVMInt1Type().

Cc: Christopher Li <sparse< at >chrisli.org>
Cc: Jeff Garzik <jgarzik< at >redhat.com>
Cc: Linus Torvalds <torvalds< at >linux-foundation.org>
Signed-off-by: Pekka Enberg <penberg< at >kernel.org>
---
 sparse-llvm.c |    3 +++
 1 files changed, 3 insertions(+), 0 deletions(-)

diff --git a/sparse-llvm.c b/sparse-llvm.c
index 38f40fc..a291a0d 100644
--- a/sparse-llvm.c
+++ b/sparse-llvm.c
< at >< at > -175,6 +175,9 < at >< at > static LLVMTypeRef sym_basetype_type(struct symbol *sym)
 }
 } else {
 switch (sym->bit_size) {
+case 1:
+ret = LLVMInt1Type();
+break;
 case -1:/* 'void *' is treated like 'char *' */
 case 8:
 ret = LLVMInt8Type();

Sparse 0.4.4 is released

Christopher Li — 2011-11-25T21:13:33

This is a long due release. The sparse 0.4.4 can be downloaded from:

http://www.kernel.org/pub/software/devel/sparse/dist/

The new sparse has a lot of bugs fixes. It will report less noise
while checking the new kernel tree. It compiles better with the
new gcc as well.

The sparse project is in the process of moving to the MIT license.
Dan is coordinating the efforts. Most sparse developers sign off
the MIT license already. If you haven't done so, please contact
Dan off the list regarding the new license.

Here is the short summery of the changes in this release.

Have a nice long week end.

Chris


Ben Pfaff (1):
      evaluate: Allow sizeof(_Bool) to succeed.

Christopher Li (13):
      inspect: adding function arugument list
      Allow overwrite CFLAGS from command line
      Ignore attribute vector_size
      Remove set but not used variable
      inspect: Add switch statement and more
      validation: inline switch statement
      Fix inlining switch statement.
      Sparse 0.4.4-rc1
      Add test

[GIT PULL] Sparse LLVM backend

Pekka Enberg — 2011-11-25T07:46:06

Hi Chris,

Please consider pulling latest LLVM backend code from:

   git://github.com/penberg/sparse-llvm.git for-chris

The backend is still work in progress but it already supports the following C
language features:

   - Arithmetic operations

   - Comparison operations

   - Logical operations

   - Bitwise operations

   - Loops

   - Casts

   - Structs and unions

The backend has been tested on i386 and x86-64. Some features have also been
tested on PPC against LLVM 2.6.

Please note that sparse uses 32-bit data type sizes by default so the generated
code on 64-bit is not correct. We'd need something like the following patch to
fix it:

   http://thread.gmane.org/gmane.comp.parsers.sparse/2654/focus=2655

 Pekka

------------------>


The following changes since commit 65a4e2fc656aa6e99604358056d8599a1823a8bc:

   sparse 0.4.4 (2011-11-21 01:56:02 -0800)

are available in the git repository at:
   git://github.com/penberg/sparse-llvm.git for-chris

Christopher Li (1):
       Limit usage of g++ to

[PATCH] sparse, llvm: Don't fail the build if LLVM is too old

Pekka Enberg — 2011-11-25T07:06:44

Disable sparse-llvm compilation if LLVM version is too old.

Cc: Linus Torvalds <torvalds< at >linux-foundation.org>
Cc: Christopher Li <sparse< at >chrisli.org>
Cc: Jeff Garzik <jgarzik< at >redhat.com>
Signed-off-by: Pekka Enberg <penberg< at >kernel.org>
---
 Makefile |   13 ++++++++++---
 1 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/Makefile b/Makefile
index e508cae..2b5976d 100644
--- a/Makefile
+++ b/Makefile
< at >< at > -23,6 +23,8 < at >< at > HAVE_GCC_DEP:=$(shell touch .gcc-test.c && \
 echo 'yes'; rm -f .gcc-test.d .gcc-test.o .gcc-test.c)
 HAVE_GTK2:=$(shell pkg-config --exists gtk+-2.0 2>/dev/null && echo 'yes')
 HAVE_LLVM:=$(shell llvm-config --version >/dev/null 2>&1 && echo 'yes')
+HAVE_LLVM_VERSION:=$(shell llvm-config --version | grep "^[3-9].*" >/dev/null 2>&1 && echo yes)
+LLVM_VERSION=$(shell llvm-config --version)
 
 GCC_BASE = $(shell $(CC) --print-file-name=)
 BASIC_CFLAGS = -DGCC_BASE=\"$(GCC_BASE)\"
< at >< at > -65,7 +67,13 < at >< at > else
 $(warning Your system does not have libgtk2, disabling test-inspect)
 end

[PATCH] sparse, llvm: FP comparison op code generation

Pekka Enberg — 2011-11-22T19:53:41

This patch implements code generation for floating point versions of OP_BINCMP.

Cc: Linus Torvalds <torvalds< at >linux-foundation.org>
Cc: Christopher Li <sparse< at >chrisli.org>
Cc: Jeff Garzik <jgarzik< at >redhat.com>
Signed-off-by: Pekka Enberg <penberg< at >kernel.org>
---
 sparse-llvm.c                |   29 +++++++++++++++++++++++++++--
 validation/backend/cmp-ops.c |   30 ++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+), 2 deletions(-)

diff --git a/sparse-llvm.c b/sparse-llvm.c
index 4ef02a1..0674ef3 100644
--- a/sparse-llvm.c
+++ b/sparse-llvm.c
< at >< at > -391,6 +391,25 < at >< at > static LLVMTypeRef pseudo_type(struct function *fn, struct instruction *insn, ps
 return result;
 }
 
+static LLVMRealPredicate translate_fop(int opcode)
+{
+static const LLVMRealPredicate trans_tbl[] = {
+[OP_SET_EQ]= LLVMRealOEQ,
+[OP_SET_NE]= LLVMRealUNE,
+[OP_SET_LE]= LLVMRealOLE,
+[OP_SET_GE]= LLVMRealOGE,
+[OP_SET_LT]= LLVMRealOLT,
+[OP_SET_GT]= LLVMRealOGT,
+/* Are these used with FP? */
+[OP_SET_B]= LLVM