When was the NULL macro not 0?

by

The C FAQ has some examples of historical machines with non-0 NULL representations.

From The C FAQ List, question 5.17:

Q: Seriously, have any actual machines really used nonzero null
pointers, or different representations for pointers to different
types?

A: The Prime 50 series used segment 07777, offset 0 for the null
pointer, at least for PL/I. Later models used segment 0, offset 0 for
null pointers in C, necessitating new instructions such as TCNP (Test
C Null Pointer), evidently as a sop to [footnote] all the extant
poorly-written C code which made incorrect assumptions. Older,
word-addressed Prime machines were also notorious for requiring larger
byte pointers (char *‘s) than word pointers (int *‘s).

The Eclipse MV series from Data General has three architecturally
supported pointer formats (word, byte, and bit pointers), two of which
are used by C compilers: byte pointers for char * and void *, and word
pointers for everything else. For historical reasons during the
evolution of the 32-bit MV line from the 16-bit Nova line, word
pointers and byte pointers had the offset, indirection, and ring
protection bits in different places in the word. Passing a mismatched
pointer format to a function resulted in protection faults.
Eventually, the MV C compiler added many compatibility options to try
to deal with code that had pointer type mismatch errors.

Some Honeywell-Bull mainframes use the bit pattern 06000 for
(internal) null pointers.

The CDC Cyber 180 Series has 48-bit pointers consisting of a ring,
segment, and offset. Most users (in ring 11) have null pointers of
0xB00000000000. It was common on old CDC ones-complement machines to
use an all-one-bits word as a special flag for all kinds of data,
including invalid addresses.

The old HP 3000 series uses a different addressing scheme for byte
addresses than for word addresses; like several of the machines above
it therefore uses different representations for char * and void *
pointers than for other pointers.

The Symbolics Lisp Machine, a tagged architecture, does not even have
conventional numeric pointers; it uses the pair <NIL, 0> (basically a
nonexistent <object, offset> handle) as a C null pointer.

Depending on the “memory model” in use, 8086-family processors (PC
compatibles) may use 16-bit data pointers and 32-bit function
pointers, or vice versa.

Some 64-bit Cray machines represent int * in the lower 48 bits of a
word; char * additionally uses some of the upper 16 bits to indicate a
byte address within a word.

More Related Contents:

  1. Passing values to macros by for loop
  2. What is the difference between NULL, ‘\0’ and 0?
  3. The need for parentheses in macros in C [duplicate]
  4. Real-world use of X-Macros
  5. Creating C macro with ## and __LINE__ (token concatenation with positioning macro)
  6. Macro definition to determine big endian or little endian machine?
  7. Is NULL always zero in C?
  8. Are typedef and #define the same in c?
  9. __FILE__ macro shows full path
  10. What exactly do C include guards do?
  11. Array-size macro that rejects pointers
  12. Can a conforming C implementation #define NULL to be something wacky
  13. What does #x inside a C macro mean?
  14. What is the result of NULL + int?
  15. Is NULL always false?
  16. How does the C offsetof macro work? [duplicate]
  17. C: Expand Macro With Token Pasting
  18. Is one’s complement a real-world issue, or just a historical one?
  19. Is there a macro definition to check the Linux kernel version?
  20. Macro to count number of arguments
  21. C Macros to create strings
  22. Macro and function with same name
  23. Macro expansion and stringification: How to get the macro name (not its value) stringified using another macro?
  24. How to pass macro definition from “make” command line arguments (-D) to C source code?
  25. Is NULL in C required/defined to be zero?
  26. What makes a better constant in C, a macro or an enum?
  27. Debug Print Macro in C?
  28. offsetof at compile time
  29. Macros to create strings in C
  30. Redefining NULL

Leave a Comment