Is failure to implicitly convert a pointer to _Bool a compiler deficiency?

Question

Answers to this question state that scalars can be converted to _Bool and that the resulting integer value of the _Bool will be 0 or 1.

The accepted answer to this question points out that pointers are scalars.

Is a failure to implicitly convert a pointer to a _Bool, therefore, a compiler bug?

E.g.:

$ cat ./main.c 
// main.c

#include <stdbool.h>

int main( int argc, char* argv )
{
  int  i;
  int* p   = &i;
  bool foo = (bool)p;
  bool bar = p;

  return 0;
}

Failing compiler (one of one):

$ /path/to/mips_fp_le-gcc --version
2.95.3
$ /path/to/mips_fp_le-gcc ./main.c 
./main.c: In function `main':
./main.c:10: incompatible types in initialization

Passing compiler (one of many):

$ gcc --version
gcc (GCC) 8.3.1 20190223 (Red Hat 8.3.1-2)
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ gcc ./main.c 
$

Note that only the implicit conversion, and not the cast (explicit conversion), is flagged as an error with the problem compiler.
Also, note that according to a comment to this question, the noted problem compiler is old - from 2001 - this may be relevant to whether this is a genuine compiler bug. (Reasons beyond my control prevent a version upgrade of the noted problem cross-compiler)

An important terminology point: There is no such thing in C as an "implicit cast". There are implicit conversions and explicit conversions. Explicit conversions are casts. — Keith Thompson, Dec 03 '19 at 00:59
What C standards does gcc 2.95.3 support? What if you compile with `gcc -std=c99`? (It's old enough that it defaults to `-std=gnu89`, and in that mode `` would exist only as an extension.) — Keith Thompson, Dec 03 '19 at 01:01
@KeithThompson - Problem compiler does not support `-std-c99`, it generates `cc1: unknown C standard 'c99'` error. — StoneThrow, Dec 03 '19 at 01:03
@KeithThompson - thank you for the terminology correction; the post is fixed accordindly. — StoneThrow, Dec 03 '19 at 01:03
I read somewhere that function pointers are implicitly converted to bool. Will try to find the source. Didn't find the source, but found a [stackoverflow question](https://stackoverflow.com/questions/25552822/why-does-pointer-to-int-convert-to-void-but-pointer-to-function-convert-to-bool) addressing this — smac89, Dec 03 '19 at 01:08

R.. GitHub STOP HELPING ICE · Accepted Answer · 2019-12-03T01:04:22.197

Yes, this is a compiler bug. While C has no implicit conversions in either direction between integer types and pointer types, nor implicit conversions between pointer types except in special cases like to/from pointer-to-void or from pointer-to-unqualified to pointer-to-qualified, it does define an implicit conversion to _Bool. (Traditionally many compilers supported such implicit conversions in other places, but doing so was harmful and was not part of the C language.)

The language about implicit conversion is under 6.5.16.1 Simple assignment:

One of the following shall hold:

the left operand has atomic, qualified, or unqualified arithmetic type, and the right has arithmetic type;

the left operand has an atomic, qualified, or unqualified version of a structure or union type compatible with the type of the right;

the left operand has atomic, qualified, or unqualified pointer type, and (considering the type the left operand would have after lvalue conversion) both operands are pointers to qualified or unqualified versions of compatible types, and the type pointed to by the left has all the qualifiers of the type pointed to by the right;

the left operand has atomic, qualified, or unqualified pointer type, and (considering the type the left operand would have after lvalue conversion) one operand is a pointer to an object type, and the other is a pointer to a qualified or unqualified version of void, and the type pointed to by the left has all the qualifiers of the type pointed to by the right;

the left operand is an atomic, qualified, or unqualified pointer, and the right is a null pointer constant; or

the left operand has type atomic, qualified, or unqualified _Bool, and the right is a pointer.

In other places in the standard where implicit conversion appears, it's specified "as if by assignment", referring to the above. For example, in 6.5.2.2 Function calls:

If the expression that denotes the called function has a type that does include a prototype, the arguments are implicitly converted, as if by assignment, ...

Note that your question is actually about initialization, which is not assignment in C but something different. However, 6.7.9 Initialization ¶11 covers it:

The initializer for a scalar shall be a single expression, optionally enclosed in braces. The initial value of the object is that of the expression (after conversion); the same type constraints and conversions as for simple assignment apply, taking the type of the scalar to be the unqualified version of its declared type.

Fascinating: so code that _implicitly_ casts, in either direction, between pointers and integer types, is actually making use of "compiler extensions" or like some kind of freebie "kindness" the compiler offers (which just happens to be the majority of compilers)? — StoneThrow, Dec 03 '19 at 00:56
Hmmm. Using a pointer in a bool context has always been allowed (`if (ptr) { blah }`) so this conversion doesn't seem too far off the rails. — Steve Friedl, Dec 03 '19 at 00:56
This is incorrect. C specifically permits implicit conversions from pointer types to `_Bool`. See [N1570](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf) 6.5.16.1. — Keith Thompson, Dec 03 '19 at 00:57
@KeithThompson: Indeed, it's even in the text I just added. Will fix. — R.. GitHub STOP HELPING ICE, Dec 03 '19 at 00:58
@SteveFriedl: That's not "a bool context". It's using an expression with pointer type as the controlling expression in a conditional, and its semantics are defined elsewhere in a way that has nothing to do with conversion to `_Bool`. — R.. GitHub STOP HELPING ICE, Dec 03 '19 at 01:00
@KeithThompson: Actually one more thing I need to check: initialization is not assignment and it might not be permitted there. — R.. GitHub STOP HELPING ICE, Dec 03 '19 at 01:01
@R.. The same rules apply to simple assignment, initialization, argument passing, and `return` statements. — Keith Thompson, Dec 03 '19 at 01:11

Is failure to implicitly convert a pointer to _Bool a compiler deficiency?

1 Answers1