guile/libguile/gc-inline.h

#ifndef SCM_GC_INLINE_H
#define SCM_GC_INLINE_H

/* Copyright 1995-1996,1998-2004,2006-2014,2018-2019,2025
     Free Software Foundation, Inc.

   This file is part of Guile.

   Guile is free software: you can redistribute it and/or modify it
   under the terms of the GNU Lesser General Public License as published
   by the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   Guile is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
   License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with Guile.  If not, see
   <https://www.gnu.org/licenses/>.  */

/* Much of this file was copied from gc_inline.h, from the BDW
 * collector.  Its copyright notice is:
 *
 * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
 * Copyright 1991-1995 by Xerox Corporation.  All rights reserved.
 * Copyright 2005 Hewlett-Packard Development Company, L.P.
 *
 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
 * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
 *
 * Permission is hereby granted to use or copy this program
 * for any purpose,  provided the above notices are retained on all copies.
 * Permission to modify the code and to distribute modified code is granted,
 * provided the above notices are retained, and a notice that the code was
 * modified is included with the above copyright notice.
 */



#include "libguile/gc.h"
#include "libguile/gc-internal.h"
#include "libguile/threads.h"



static inline void *
scm_inline_allocate_pointerless (scm_thread *thread, size_t bytes)
{
  return gc_allocate (thread->mutator, bytes,
                      GC_ALLOCATION_UNTAGGED_POINTERLESS);
}

static inline void *
scm_inline_allocate_tagged (scm_thread *thread, size_t bytes)
{
  return gc_allocate (thread->mutator, bytes,
                      GC_ALLOCATION_TAGGED);
}

static inline void *
scm_inline_allocate_sloppy (scm_thread *thread, size_t bytes)
{
  return gc_allocate (thread->mutator, bytes,
                      GC_ALLOCATION_UNTAGGED_CONSERVATIVE);
}

static inline void *
scm_inline_gc_malloc_pointerless (scm_thread *thread, size_t bytes)
{
  return gc_allocate (thread->mutator, bytes,
                      GC_ALLOCATION_UNTAGGED_POINTERLESS);
}

static inline void *
scm_inline_gc_malloc (scm_thread *thread, size_t bytes)
{
  return gc_allocate (thread->mutator, bytes, GC_ALLOCATION_TAGGED);
}

static inline void *
scm_inline_gc_malloc_words (scm_thread *thread, size_t words)
{
  return scm_inline_gc_malloc (thread, words * sizeof (void *));
}

static inline void *
scm_inline_gc_malloc_pointerless_words (scm_thread *thread, size_t words)
{
  return scm_inline_gc_malloc_pointerless (thread, words * sizeof (void *));
}

static inline SCM
scm_inline_cell (scm_thread *thread, scm_t_bits car, scm_t_bits cdr)
{
  SCM cell = SCM_PACK_POINTER (scm_inline_gc_malloc_words (thread, 2));
  
  SCM_GC_SET_CELL_WORD (cell, 0, car);
  SCM_GC_SET_CELL_WORD (cell, 1, cdr);

  return cell;
}

static inline SCM
scm_inline_double_cell (scm_thread *thread, scm_t_bits car, scm_t_bits cbr,
                           scm_t_bits ccr, scm_t_bits cdr)
{
  SCM cell = SCM_PACK_POINTER (scm_inline_gc_malloc_words (thread, 4));
  
  SCM_GC_SET_CELL_WORD (cell, 0, car);
  SCM_GC_SET_CELL_WORD (cell, 1, cbr);
  SCM_GC_SET_CELL_WORD (cell, 2, ccr);
  SCM_GC_SET_CELL_WORD (cell, 3, cdr);

  return cell;
}

static inline SCM
scm_inline_words (scm_thread *thread, scm_t_bits car, uint32_t n_words)
{
  SCM obj = SCM_PACK_POINTER (scm_inline_gc_malloc_words (thread, n_words));
  
  SCM_GC_SET_CELL_WORD (obj, 0, car);

  return obj;
}

static inline SCM
scm_inline_cons (scm_thread *thread, SCM x, SCM y)
{
  return scm_inline_cell (thread, SCM_UNPACK (x), SCM_UNPACK (y));
}


#endif  /* SCM_GC_INLINE_H */