Suppressing "Parameter not used" Warning

Do you have a question? Post it now! No Registration Necessary

Translate This Thread From English to

Threaded View
Please note crosspost.  

Often when writing code requiring function pointers, it is necessary
to write functions that ignore their formal parameters.  For example,
a state machine function might take a status input, but a certain
error-handling state might ignore it:

   typedef void (*State_Fn)(uint8_t);

   void error_state(uint8_t status)
   {
      NOT_USED(status);

      /* code handling error but ignoring status */
   }

In another group, a poster asked about defining a macro NOT_USED as
shown above to quiet the compiler warning.  His suggested
implementation was

   #define NOT_USED(p) ((void)(p))

In this particular case, he noted the compiler he was using would
generate the warning even in the presence of this macro.  I suggested
he use

   #define NOT_USED(p) ((p)=(p))

He was pleased that it worked, but was concerned that the former
implementation was more widely supported, and that the latter might
generate executable code.  I for one had never seen the former before,
though I've often seen the latter (usually not hidden behind a macro),
and I've never seen it actually generate code.  At least, not in the
last ten years or so.

So I'm curious.  Which form (if either) is more common?  Are there any
implementations that will generate executable code for the latter?

Thanks,
   -=Dave

                               -=Dave
--
Change is inevitable, progress is not.

Re: Suppressing "Parameter not used" Warning
Quoted text here. Click to load it

Non executable code tends to generate warnings.

Quoted text here. Click to load it

In distributions file for a sort timing program
my distribution function arguments are of this form:
(e_type *array, size_t n, long unsigned *seed)

but only some of them use the seed for a PRNG.

Others are like this:

void sorted(e_type *a, size_t n, long unsigned *seed)
{
    a += n;
    while (n-- != 0) {
        (*--a).data = n;
    }
    seed;
}

So, I just make an expression statement out of seed
and that seems to stop the warnings.

--
pete

Re: Suppressing "Parameter not used" Warning
Quoted text here. Click to load it

But some compilers will issue a warning about the
"expression" result not being used...

Re: Suppressing "Parameter not used" Warning
...
Quoted text here. Click to load it

OK, what if the seed is used in an expression containing a comma, to the
left side of the comma?

Or what if it's used in an expression as
(seed*0)
or
(seed&0)
or
(seed&&0)?
:)
Should the compiler grumble in these 3 latter cases?

Alex



Re: Suppressing "Parameter not used" Warning
On Tue, 4 Oct 2005 21:31:58 +0400, "Alexei A. Frounze"

[...]
Quoted text here. Click to load it

Depends.  What's on the right side on the comma?  Is the comma
expression cast to void?

Quoted text here. Click to load it

Many compilers won't, but some will, and lint certainly will, unless
the expression is cast to void.

Regards,

                               -=Dave
--
Change is inevitable, progress is not.

Re: Suppressing "Parameter not used" Warning
Quoted text here. Click to load it

I don't know. It was just an idea...

Quoted text here. Click to load it

No, my point was that to make it a part of the expression whose value *is*
used but happens to be unaffected by seed being multiplied by 0 or anded
with 0.

Alex



Re: Suppressing "Parameter not used" Warning
On Tue, 4 Oct 2005 23:23:39 +0400, "Alexei A. Frounze"

[...]
Quoted text here. Click to load it

Oh, OK, I understand now.  I expect there's a good chance it will
work.  But it's kind of hard to hide behind a macro.

Regards,

                               -=Dave
--
Change is inevitable, progress is not.

Re: Suppressing "Parameter not used" Warning

Quoted text here. Click to load it



Why not just

void error_state( uint8_t ) /* don't care about formal parameter */
{
  /* code */
}

?  (I'm not enough of a guru to answer your real question.)

--
Christopher Benson-Manica  | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org    | don't, I need to know.  Flames welcome.

Re: Suppressing "Parameter not used" Warning
Quoted text here. Click to load it
Because that's not legal C. If it were, we obviously wouldn't need any
hacks. You can do this in prototypes; in C++ you can also do it in
definitions. Not in C, however.

S.

Re: Suppressing "Parameter not used" Warning

Quoted text here. Click to load it

My apologies; I use C++, and this was a difference of which I was not
aware.  Thanks.

--
Christopher Benson-Manica  | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org    | don't, I need to know.  Flames welcome.

Re: Suppressing "Parameter not used" Warning


Dave Hansen wrote On 10/03/05 10:13,:
Quoted text here. Click to load it

    First, there is no sure-fire way to prevent compilers
from issuing diagnostics.  The compiler is entitled to
grouse about anything it chooses, provided it accepts code
that does not actually contravene the Standard.  It can
warn about spellnig errors in comennts, or about inconsistent
indentation levels.  The requirement "No warnings from any
compiler" is not ultimately tenable.

    FWIW, the `(void)p' formulation seems to be widespread.
Even if a compiler complains about it, a human reader will
see immediately that it was in fact the programmer's intent
that `p' remain unused -- the programmer may have made a
mistake, but at least it was not one of simple inattention.

    I don't think `(p)=(p)' is a wonderful idea.  If `p' is
volatile the generated code must perform both the read and the
write.  If `p' is `const' the compiler is required to issue a
diagnostic, so you're no better off than when you started --
worse, if anything.  Of course, `const'-qualified function
parameters are fairly unusual and `volatile' parameters are
exceedingly rare, but the possibilities exist.

    In any case, hiding the actual trickery behind a NOT_USED
macro seems a good idea: you can re-#define NOT_USED as part
of your adaptation to each new compiler that comes along,
using whatever compiler-specific dodge seems to work best.

--
snipped-for-privacy@sun.com


Re: Suppressing "Parameter not used" Warning
Quoted text here. Click to load it

An alternative would be to invoke the compiler using a flag or option
that disables the unused variable/parameter warning.

However, it's good practice to turn the warning back on every once
in a while and see if any unexpected unused thingies have crept into
the code.

Re: Suppressing "Parameter not used" Warning
Quoted text here. Click to load it

I use the first version, a cast-to-void macro.  It works fine for gcc
(various ports).

Re: Suppressing "Parameter not used" Warning

Quoted text here. Click to load it


Very slightly OT, but I just use gcc's __attribute__((unused)).
I realize it's not-portable to other compilers, but...

 1) In my applications so much of the code is platform-specific
    that it just doesn't matter.

 2) I've used nothing but gcc for embedded work for the past 6
    or 7 years anyway.  

--
Grant Edwards                   grante             Yow!  Will the third world
                                  at               war keep "Bosom Buddies"
We've slightly trimmed the long signature. Click to see the full one.
Re: Suppressing "Parameter not used" Warning
Quoted text here. Click to load it

Also OT, but the warning that bugs me most with gcc is "warning: will
never be executed" on code that gets removed by the optimiser.  If I've
written code that really cannot ever be executed, it's (almost
certainly) a mistake, so I want the compiler to tell me.  But on code
like this:

    if (test()) {
        doThis();
        doThat();
    } else {
        doSomethingElse();
        doThat();
    }

gcc will combine the two "doThat()" calls (which is good), and then warn
that one of the "will never be executed", which is bad.

If you know any good ideas to get working "will never be executed"
warnings, even if it is "wait for gcc 4.1.x", I'd love to hear them.

Re: Suppressing "Parameter not used" Warning
Quoted text here. Click to load it

Hmmm. I tried this with a couple of GCC versions at default
and -O[23] optimization levels (cross and native) and saw no
such warning. What options/versions are you using?

--
Michael N. Moran           (h) 770 516 7918
5009 Old Field Ct.         (c) 678 521 5460
We've slightly trimmed the long signature. Click to see the full one.
Re: Suppressing "Parameter not used" Warning
Quoted text here. Click to load it

As is typical when you write something off the top of your head, my test
case didn't work.  Additionally, you need the "-Wunreachable-code"
warning flag on to get the warning.  A bit more testing showed that the
following code gives an unwanted warning with msp430-gcc (3.2.3), but
not for avr-gcc (3.4.1).  Both give a correct warning on test2().  So it
looks like I've answered my own question - use gcc 3.4 or newer.  (gcc
4.x for msp430 should not be too far off, I hope.)


unsigned char a, b, c, d;

void test(void) {
    if (a == 1) {
        b = 100;        // Should be no warning here
    } else if (a == 2) {
        b = 200;
    } else {
        b = 100;
    }
}

void test2(void) {
    if (c) {
        d = 10;
    } else if (!c) {
        d = 20;
    } else {
        d = 30;            // Should give warning here
    }
}

Re: Suppressing "Parameter not used" Warning
...
Quoted text here. Click to load it
...

Also: borland, watcom, a few less popilar ones. I don't remember about
msvc++. Probably too.
Alex



Re: Suppressing "Parameter not used" Warning
Quoted text here. Click to load it

Yes, the compiler might warn that 'p' is assigned a value which
is never used. And it might also warn about reading an uninitialized
variable.

One compiler I use has this definition:

    #define NOT_USED(junk)   { (volatile typeof(junk))junk = junk; }


Re: Suppressing "Parameter not used" Warning
Quoted text here. Click to load it

In fact, strictly speaking, this could invoke undefined behavior if p
really hasn't been initialized.  Since it's a parameter (at least in
the context intended by the OP), that would happen only if the caller
passes an uninitialized value, so it would require some additional
smarts by the compiler to detect the problem.

On most real-world systems, this isn't going to cause any visible
problems, but it's possible that certain pointer values can cause a
trap when you try to load them into a register, even if there's no
attempt to dereference the value.  The same could apply to any type
that can have trap representations.

Hiding this behind a NOT_USED macro is a good idea.  The definition of
the macro can probably be made to vary depending on what system you're
on, using the usual twisty maze of #ifdefs method.

The ((p)=(p)) trick is ok if you make sure p is always initialized,
even to a meaningless value.

As others have mentioned, there is no portable way to control specific
warnings that will work across implementations.

--
Keith Thompson (The_Other_Keith) snipped-for-privacy@mib.org  <http://www.ghoti.net/~kst
San Diego Supercomputer Center             <*>  <http://users.sdsc.edu/~kst
We've slightly trimmed the long signature. Click to see the full one.

Site Timeline