How is VALUE in Ruby sometimes a pointer, and sometimes not?

I mean they basically assume that there can't be a pointer with any of the first 3 bits (or more) set.

Here's a function that determines the type of a value:

static inline enum ruby_value_type
rb_type(VALUE obj)
{
    if (! RB_SPECIAL_CONST_P(obj)) {
        return RB_BUILTIN_TYPE(obj);
    }
    else if (obj == RUBY_Qfalse) {
        return RUBY_T_FALSE;
    }
    else if (obj == RUBY_Qnil) {
        return RUBY_T_NIL;
    }
    else if (obj == RUBY_Qtrue) {
        return RUBY_T_TRUE;
    }
    else if (obj == RUBY_Qundef) {
        return RUBY_T_UNDEF;
    }
    ...

RUBY_Q* are constants:

    RUBY_Qfalse         = 0x00, /* ...0000 0000 */
    RUBY_Qnil           = 0x04, /* ...0000 0100 */
    RUBY_Qtrue          = 0x14, /* ...0001 0100 */
    RUBY_Qundef         = 0x24, /* ...0010 0100 */
    RUBY_IMMEDIATE_MASK = 0x07, /* ...0000 0111 */
    RUBY_FIXNUM_FLAG    = 0x01, /* ...xxxx xxx1 */
    RUBY_FLONUM_MASK    = 0x03, /* ...0000 0011 */
    RUBY_FLONUM_FLAG    = 0x02, /* ...xxxx xx10 */
    RUBY_SYMBOL_FLAG    = 0x0c, /* ...xxxx 1100 */
    ...
    RUBY_SPECIAL_SHIFT  = 8 /**< Least significant 8 bits are reserved. */

RB_SPECIAL_CONST_P():

static inline bool
RB_SPECIAL_CONST_P(VALUE obj)
{
    return RB_IMMEDIATE_P(obj) || obj == RUBY_Qfalse;
}

RB_IMMEDIATE_P():

static inline bool
RB_IMMEDIATE_P(VALUE obj)
{
    return obj & RUBY_IMMEDIATE_MASK;
}

RB_BUILTIN_TYPE:

static inline enum ruby_value_type
RB_BUILTIN_TYPE(VALUE obj)
{
    ...
    VALUE ret = RBASIC(obj)->flags & RUBY_T_MASK;
    return RBIMPL_CAST((enum ruby_value_type)ret);
}

RBASIC:

#define RBASIC(obj)                 RBIMPL_CAST((struct RBasic *)(obj))

So, unless the first 3 bits are set, they use VALUE as a pointer. What makes them sure they won't one day receive a pointer with any of those bits set?

All pointers to objects from ruby will come from malloc et. al.

From the man page for malloc:
>The malloc() and calloc() functions return a pointer to the allocated
memory, which is suitably aligned for any built-in type.

Thus, malloc must allow (e.g.):

double *dptr = malloc(sizeof(*dptr));

The alignment for double is 8 bytes.

This is true for all [all POSIX compliant] systems.
Actually, it's usually the CPU architecture that dictates the alignment.

• Some systems require such alignment (or an access will cause the H/W to generate an alignment exception).
• Even if the H/W will tolerate a non-aligned fetch/store, the S/W will generate the natural alignment anyway [sometimes for performance reasons--the aligned access can be faster].

So, at a minimum, the least significant bits 3 bits of a pointer must be 0.

For some arches, the compiler supports (e.g.) __int128, so the required alignment would be 16.

Also, some systems (e.g. x86) also support SIMD types which are 16 bytes. So, again, an alignment of 16 bytes.

For 16 byte alignment, the least significant 4 bits would be 0.

Although you only rely on 8 byte alignment [and LSB of 3 being 0], frequently

So, always, you can rely on the least significant 3 bits being 0.