gc.h

Go to the documentation of this file.

#ifndef RBIMPL_GC_H                                  /*-*-C++-*-vi:se ft=cpp:*/
#define RBIMPL_GC_H
#include "ruby/internal/config.h"
 
#ifdef STDC_HEADERS
# include <stddef.h>                       /* size_t */
#endif
 
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>                    /* ssize_t */
#endif
 
#include "ruby/assert.h"
#include "ruby/internal/attr/cold.h"
#include "ruby/internal/attr/nonnull.h"
#include "ruby/internal/attr/noreturn.h"
#include "ruby/internal/attr/artificial.h"
#include "ruby/internal/attr/maybe_unused.h"
#include "ruby/internal/attr/pure.h"
#include "ruby/internal/dllexport.h"
#include "ruby/internal/special_consts.h"
#include "ruby/internal/stdbool.h"
#include "ruby/internal/value.h"
 
RBIMPL_SYMBOL_EXPORT_BEGIN()
 
#define RUBY_REF_EDGE(s, p) offsetof(s, p)
#define RUBY_REFS_LIST_PTR(l) (RUBY_DATA_FUNC)(uintptr_t)(l)
#define RUBY_REF_END SIZE_MAX
#define RUBY_REFERENCES(t) static const size_t t[]
#define RUBY_REFERENCES_START(t) RUBY_REFERENCES(t) = {
#define RUBY_REFERENCES_END RUBY_REF_END, };
 
/* gc.c */
 
RBIMPL_ATTR_COLD()
RBIMPL_ATTR_NORETURN()
void rb_memerror(void);
 
RBIMPL_ATTR_PURE()
int rb_during_gc(void);
 
RBIMPL_ATTR_NONNULL((1))
void rb_gc_mark_locations(const VALUE *start, const VALUE *end);
 
void rb_mark_tbl(struct st_table *tbl);
 
void rb_mark_tbl_no_pin(struct st_table *tbl);
 
void rb_mark_set(struct st_table *tbl);
 
void rb_mark_hash(struct st_table *tbl);
 
void rb_gc_update_tbl_refs(st_table *ptr);
 
void rb_gc_mark_maybe(VALUE obj);
 
void rb_gc_mark(VALUE obj);
 
void rb_gc_mark_movable(VALUE obj);
 
VALUE rb_gc_location(VALUE obj);
 
void rb_gc_update_moved(VALUE *ptr);
 
void rb_gc(void);
 
void rb_gc_copy_finalizer(VALUE dst, VALUE src);
 
VALUE rb_gc_enable(void);
 
VALUE rb_gc_disable(void);
 
VALUE rb_gc_start(void);
 
VALUE rb_define_finalizer(VALUE obj, VALUE block);
 
VALUE rb_undefine_finalizer(VALUE obj);
 
size_t rb_gc_count(void);
 
size_t rb_gc_stat(VALUE key_or_buf);
 
VALUE rb_gc_latest_gc_info(VALUE key_or_buf);
 
void rb_gc_adjust_memory_usage(ssize_t diff);
 
void rb_gc_register_address(VALUE *valptr);
 
void rb_global_variable(VALUE *);
 
void rb_gc_unregister_address(VALUE *valptr);
 
void rb_gc_register_mark_object(VALUE object);
 
RBIMPL_SYMBOL_EXPORT_END()
 
#undef USE_RGENGC
#define USE_RGENGC 1
 
#ifndef USE_RGENGC_LOGGING_WB_UNPROTECT
# define USE_RGENGC_LOGGING_WB_UNPROTECT 0
#endif
 
#define RB_OBJ_WRITE(old, slot, young) \
    RBIMPL_CAST(rb_obj_write((VALUE)(old), (VALUE *)(slot), (VALUE)(young), __FILE__, __LINE__))
 
#define RB_OBJ_WRITTEN(old, oldv, young) \
    RBIMPL_CAST(rb_obj_written((VALUE)(old), (VALUE)(oldv), (VALUE)(young), __FILE__, __LINE__))
#define OBJ_PROMOTED_RAW RB_OBJ_PROMOTED_RAW 
#define OBJ_PROMOTED     RB_OBJ_PROMOTED     
#define OBJ_WB_UNPROTECT RB_OBJ_WB_UNPROTECT 
#define RB_OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__)
 
#define RB_OBJ_WB_UNPROTECT_FOR(type, obj) OBJ_WB_UNPROTECT(obj)
 
#define RGENGC_LOGGING_WB_UNPROTECT rb_gc_unprotect_logging
 
#define RB_OBJ_PROMOTED_RAW RB_OBJ_PROMOTED_RAW
#define RB_OBJ_PROMOTED     RB_OBJ_PROMOTED
RBIMPL_SYMBOL_EXPORT_BEGIN()
void rb_gc_writebarrier(VALUE old, VALUE young);
 
void rb_gc_writebarrier_unprotect(VALUE obj);
 
#if USE_RGENGC_LOGGING_WB_UNPROTECT
void rb_gc_unprotect_logging(void *objptr, const char *filename, int line);
#endif
 
RBIMPL_SYMBOL_EXPORT_END()
 
RBIMPL_ATTR_PURE_UNLESS_DEBUG()
RBIMPL_ATTR_ARTIFICIAL()
static inline bool
RB_OBJ_PROMOTED_RAW(VALUE obj)
{
    RBIMPL_ASSERT_OR_ASSUME(RB_FL_ABLE(obj));
    return RB_FL_ANY_RAW(obj,  RUBY_FL_PROMOTED);
}
 
RBIMPL_ATTR_PURE_UNLESS_DEBUG()
RBIMPL_ATTR_ARTIFICIAL()
static inline bool
RB_OBJ_PROMOTED(VALUE obj)
{
    if (! RB_FL_ABLE(obj)) {
        return false;
    }
    else {
        return RB_OBJ_PROMOTED_RAW(obj);
    }
}
 
static inline VALUE
rb_obj_wb_unprotect(
    VALUE x,
    RBIMPL_ATTR_MAYBE_UNUSED()
    const char *filename,
    RBIMPL_ATTR_MAYBE_UNUSED()
    int line)
{
#if USE_RGENGC_LOGGING_WB_UNPROTECT
    RGENGC_LOGGING_WB_UNPROTECT(RBIMPL_CAST((void *)x), filename, line);
#endif
    rb_gc_writebarrier_unprotect(x);
    return x;
}
 
static inline VALUE
rb_obj_written(
    VALUE a,
    RBIMPL_ATTR_MAYBE_UNUSED()
    VALUE oldv,
    VALUE b,
    RBIMPL_ATTR_MAYBE_UNUSED()
    const char *filename,
    RBIMPL_ATTR_MAYBE_UNUSED()
    int line)
{
#if USE_RGENGC_LOGGING_WB_UNPROTECT
    RGENGC_LOGGING_OBJ_WRITTEN(a, oldv, b, filename, line);
#endif
 
    if (!RB_SPECIAL_CONST_P(b)) {
        rb_gc_writebarrier(a, b);
    }
 
    return a;
}
 
static inline VALUE
rb_obj_write(
    VALUE a, VALUE *slot, VALUE b,
    RBIMPL_ATTR_MAYBE_UNUSED()
    const char *filename,
    RBIMPL_ATTR_MAYBE_UNUSED()
    int line)
{
#ifdef RGENGC_LOGGING_WRITE
    RGENGC_LOGGING_WRITE(a, slot, b, filename, line);
#endif
 
    *slot = b;
 
    rb_obj_written(a, RUBY_Qundef /* ignore `oldv' now */, b, filename, line);
    return a;
}
 
#endif /* RBIMPL_GC_H */