[Bug c/31893] New: Please provide an "inout" attribute for function parameters.

[Bug c/31893] New: Please provide an "inout" attribute for function parameters.

[madcoder at debian dot org]

Here is what I mean. When you write code like:

int foo(void) {
    static bar_t bar;

    call_some_function(&bar);
    return 0;
}

gcc assumes that call_some_function will initialize bar properly. Though,
sometimes call_some_function is a function that will modify 'bar' but also need
it to be properly initialized. In that case, the parameter is inout. (I must
say I'm unsure what gcc thinks if call_some_function prototype is: void
call_some_function(const bar_t *); maybe it suffers from the same problem).

That'd be great to have an __attribute__((inout(1,2,3...))) to say that the
1st, 2nd, 3rd, ... variables of the function need their argument to be
initialized. That would make gcc issue warning about variables beeing used
uninitialized properly.

Maybe "inout" is a very lousy name, and I don't care much about it. My point
is, I'd really like to be able to express in the function prototypes that a
structure needs to be initialized before that function can be called. WIth this
attribute, the call_some_function prototype would be:

int call_some_function(bar_t *) __attribute__((inout(1)));


-- 
           Summary: Please provide an "inout" attribute for function
                    parameters.
           Product: gcc
           Version: unknown
            Status: UNCONFIRMED
          Severity: enhancement
          Priority: P3
         Component: c
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: madcoder at debian dot org


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31893

[Bug c/31893] Please provide an "inout" attribute for function parameters.

[madcoder at debian dot org]

------- Comment #1 from madcoder at debian dot org  2007-05-10 11:12 -------
It seems that even if the argument is declared const foo_t * gcc assumes the
function will initialize the data, which is rather ... erm... strange. Here is
the testcase:

======================================================
struct foo { int toto; };

void do_bar(const struct foo *);

int main(void) {
    struct foo foo;
    do_bar(&foo);
    return 0;
}
======================================================

gcc -Wall -Wextra -O2 -Wuninitialized -c -o foo.o foo.c

gives no warning while I'd expect to have one as do_bar takes a const foo_t *
hence should not initialize it.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31893

[Bug c/31893] Please provide an "inout" attribute for function parameters.

[pinskia at gcc dot gnu dot org]

------- Comment #2 from pinskia at gcc dot gnu dot org  2007-05-10 23:00 -------
What are you doing, writting Fortran code in C? :) (really I am serious about
this one too)

> It seems that even if the argument is declared const foo_t * gcc assumes the
> function will initialize the data, which is rather ... erm... strange.

Why do you think it is strange? you can remove the const part in do_bar
anyways.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31893

[Bug c/31893] Please provide an "inout" attribute for function parameters.

[madcoder at debian dot org]

------- Comment #3 from madcoder at debian dot org  2007-05-11 09:32 -------
Subject: Re:  Please provide an "inout" attribute for function parameters.

On Thu, May 10, 2007 at 10:00:51PM -0000, pinskia at gcc dot gnu dot org wrote:
> ------- Comment #2 from pinskia at gcc dot gnu dot org  2007-05-10 23:00 -------
> What are you doing, writting Fortran code in C? :) (really I am serious about
> this one too)
>
> > It seems that even if the argument is declared const foo_t * gcc assumes the
> > function will initialize the data, which is rather ... erm... strange.
>
> Why do you think it is strange? you can remove the const part in do_bar
> anyways.

  I know you *can* but it's very bad practice, and when you're a warning
freak like I am, I won't mark a variable "const" if the function will
eventually change it. Anyways, that does not changes my request, that is
to mark the fact that the data must be pre-initialized before use to
make -Wuninitialized even more useful :)


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31893

[Bug c/31893] Please provide an "inout" attribute for function parameters.

[manu at gcc dot gnu dot org]

------- Comment #4 from manu at gcc dot gnu dot org  2008-08-18 16:50 -------
This would need to be a GCC extension and those need some high-level approval,
so still unconfirmed, however I am marking as waiting until a decision is
taken.

You should seek opinions/support in the gcc mailing list. It seems no one has
asked for such an extension before.

I think the standard answer will be "GCC is a C compiler, use other language if
you want other features" but who knows...


-- 

manu at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |manu at gcc dot gnu dot org
             Status|UNCONFIRMED                 |WAITING


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31893

[Bug c/31893] Please provide an "inout" attribute for function parameters.

[manu at gcc dot gnu dot org]

------- Comment #5 from manu at gcc dot gnu dot org  2008-08-18 17:14 -------
There is no support for this in the middle-end anyway. Not even for Fortran.


-- 

manu at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
  BugsThisDependsOn|                            |31094


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31893

[Bug c/31893] Please provide an "inout" attribute for function parameters.

[manu at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31893

Manuel López-Ibáñez <manu at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|WAITING                     |NEW

--- Comment #6 from Manuel López-Ibáñez <manu at gcc dot gnu.org> 2012-03-16 23:22:35 UTC ---
(In reply to comment #5)
> There is no support for this in the middle-end anyway. Not even for Fortran.

And with GCC 4.7.0, there is, and FORTRAN is using it. See PR43665 and 

http://gcc.gnu.org/ml/gcc-patches/2010-04/msg00895.html

but there is no external interface exposing this functionality in C/C++. That
thread includes some suggestions. If you are still interested, you could try to
submit a patch implementing some of the suggestions.

[Bug c/31893] Please provide an "inout" attribute for function parameters.

[rguenth at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31893

Bug 31893 depends on bug 31094, which changed state.

Bug 31094 Summary: Support annotating function parameters as read-only and/or non-escaping
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31094

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|WAITING                     |RESOLVED
         Resolution|---                         |FIXED

[Bug c/31893] Please provide an "inout" attribute for function parameters.

[bugzilla@poradnik-webmastera.com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=31893

Daniel Fruzynski <bugzilla@poradnik-webmastera.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |bugzilla@poradnik-webmaster
                   |                            |a.com

--- Comment #7 from Daniel Fruzynski <bugzilla@poradnik-webmastera.com> ---
I am looking for something similar - I want to mark function argument as an
output-only. Now when I compile following code with -Wall -O1 (using gcc
4.4.7), I get following waring: 'myVar' may be used uninitialized in this
function. With help of new function or function argument attribute this warning
would go away. This new attribute may also enable additional code optimizations
and warnings. I propose syntax __attribute__((out)).

void __attribute__((const)) func(int* i)
{
    *i = 44;
}

int func2()
{
    int myVal;
    func(&myVal);
    return myVal;
}

[Bug c/31893] Please provide an "inout" attribute for function parameters.

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=31893

--- Comment #8 from Jonathan Wakely <redi at gcc dot gnu.org> ---
(In reply to Daniel Fruzynski from comment #7)
> void __attribute__((const)) func(int* i)
> {
>     *i = 44;
> }

You get a warning because you marked this function const, which tells the
compiler it won't modify *i, so you lied to the compiler.

You should not be marking this function const.