src/st-object.h

   1 /*
   2  * st-object.h
   3  *
   4  * Copyright (C) 2008 Vincent Geddes
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23 */
  24
  25 #ifndef __ST_OBJECT_H__
  26 #define __ST_OBJECT_H__
  27
  28 #include <st-types.h>
  29 #include <st-small-integer.h>
  30 #include <st-utils.h>
  31 #include <st-universe.h>
  32
  33 #define ST_HEADER(oop)        ((struct st_header *) st_detag_pointer (oop))
  34 #define ST_OBJECT_MARK(oop)   (ST_HEADER (oop)->mark)
  35 #define ST_OBJECT_CLASS(oop)  (ST_HEADER (oop)->class)
  36 #define ST_OBJECT_FIELDS(oop) (ST_HEADER (oop)->fields)
  37
  38 /* Every heap-allocated object starts with this header word */
  39 /* format of mark oop
  40  * [ unused: 16 | instance-size: 8 | format: 6 | tag: 2 ]
  41  *
  42  *
  43  * format:      object format
  44  * mark:        object contains a forwarding pointer
  45  * unused:      not used yet (haven't implemented GC)
  46  *
  47  */
  48 struct st_header
  49 {
  50     st_oop mark;
  51     st_oop class;
  52     st_oop fields[];
  53 };
  54
  55 #define _ST_OBJECT_SET_BITFIELD(bitfield, field, value)                 \
  56     ((bitfield) = (((bitfield) & ~(_ST_OBJECT_##field##_MASK << _ST_OBJECT_##field##_SHIFT)) \
  57                  | (((value) & _ST_OBJECT_##field##_MASK) << _ST_OBJECT_##field##_SHIFT)))
  58
  59 #define _ST_OBJECT_GET_BITFIELD(bitfield, field)                        \
  60     (((bitfield) >> _ST_OBJECT_##field##_SHIFT) & _ST_OBJECT_##field##_MASK)
  61
  62 enum
  63 {
  64     _ST_OBJECT_UNUSED_BITS   = 15,
  65     _ST_OBJECT_HASH_BITS     = 1,
  66     _ST_OBJECT_SIZE_BITS     = 8,
  67     _ST_OBJECT_FORMAT_BITS   = 6,
  68
  69     _ST_OBJECT_FORMAT_SHIFT  =  ST_TAG_SIZE,
  70     _ST_OBJECT_SIZE_SHIFT    = _ST_OBJECT_FORMAT_BITS + _ST_OBJECT_FORMAT_SHIFT,
  71     _ST_OBJECT_HASH_SHIFT    = _ST_OBJECT_SIZE_BITS  + _ST_OBJECT_SIZE_SHIFT,
  72     _ST_OBJECT_UNUSED_SHIFT  = _ST_OBJECT_HASH_BITS   + _ST_OBJECT_HASH_SHIFT,
  73
  74     _ST_OBJECT_FORMAT_MASK   = ST_NTH_MASK (_ST_OBJECT_FORMAT_BITS),
  75     _ST_OBJECT_SIZE_MASK     = ST_NTH_MASK (_ST_OBJECT_SIZE_BITS),
  76     _ST_OBJECT_HASH_MASK     = ST_NTH_MASK (_ST_OBJECT_HASH_BITS),
  77     _ST_OBJECT_UNUSED_MASK   = ST_NTH_MASK (_ST_OBJECT_UNUSED_BITS),
  78 };
  79
  80 /* Make sure to update all cased code in VM when adding a new format */
  81 typedef enum st_format
  82 {
  83     ST_FORMAT_OBJECT,
  84     ST_FORMAT_FLOAT,
  85     ST_FORMAT_LARGE_INTEGER,
  86     ST_FORMAT_HANDLE,
  87     ST_FORMAT_ARRAY,
  88     ST_FORMAT_BYTE_ARRAY,
  89     ST_FORMAT_FLOAT_ARRAY,
  90     ST_FORMAT_INTEGER_ARRAY,
  91     ST_FORMAT_WORD_ARRAY,
  92     ST_FORMAT_CONTEXT,
  93     ST_NUM_FORMATS
  94 } st_format;
  95
  96 st_oop  st_object_allocate          (st_oop class);
  97 void    st_object_initialize_header (st_oop object, st_oop class);
  98 bool    st_object_equal             (st_oop object, st_oop other);
  99 st_uint st_object_hash              (st_oop object);
 100
 101 static inline void
 102 st_object_set_format (st_oop object, st_format format)
 103 {
 104     _ST_OBJECT_SET_BITFIELD (ST_OBJECT_MARK (object), FORMAT, format);
 105 }
 106
 107 static inline st_format
 108 st_object_format (st_oop object)
 109 {
 110     return _ST_OBJECT_GET_BITFIELD (ST_OBJECT_MARK (object), FORMAT);
 111 }
 112
 113 static inline void
 114 st_object_set_hashed (st_oop object, bool hashed)
 115 {
 116     _ST_OBJECT_SET_BITFIELD (ST_OBJECT_MARK (object), HASH, hashed);
 117 }
 118
 119 static inline bool
 120 st_object_is_hashed (st_oop object)
 121 {
 122     return _ST_OBJECT_GET_BITFIELD (ST_OBJECT_MARK (object), HASH);
 123 }
 124
 125
 126 static inline st_uint
 127 st_object_instance_size (st_oop object)
 128 {
 129     return _ST_OBJECT_GET_BITFIELD (ST_OBJECT_MARK (object), SIZE);
 130 }
 131
 132 static inline st_uint
 133 st_object_set_instance_size (st_oop object, st_uint size)
 134 {
 135     _ST_OBJECT_SET_BITFIELD (ST_OBJECT_MARK (object), SIZE, size);
 136 }
 137
 138 static inline int
 139 st_object_tag (st_oop object)
 140 {
 141     return object & st_tag_mask;
 142 }
 143
 144 static inline bool
 145 st_object_is_heap (st_oop object)
 146 {
 147     return st_object_tag (object) == ST_POINTER_TAG;
 148 }
 149
 150 static inline bool
 151 st_object_is_smi (st_oop object)
 152 {
 153     return st_object_tag (object) == ST_SMI_TAG;
 154 }
 155
 156 static inline bool
 157 st_object_is_character (st_oop object)
 158 {
 159     return st_object_tag (object) == ST_CHARACTER_TAG;
 160 }
 161
 162 static inline bool
 163 st_object_is_mark (st_oop object)
 164 {
 165     return st_object_tag (object) == ST_MARK_TAG;
 166 }
 167
 168 static inline st_oop
 169 st_object_class (st_oop object)
 170 {
 171     if (ST_UNLIKELY (st_object_is_smi (object)))
 172         return ST_SMI_CLASS;
 173
 174     if (ST_UNLIKELY (st_object_is_character (object)))
 175         return ST_CHARACTER_CLASS;
 176
 177     return ST_OBJECT_CLASS (object);
 178 }
 179
 180 static inline bool
 181 st_object_is_symbol (st_oop object)
 182 {
 183     return st_object_class (object) == ST_SYMBOL_CLASS;
 184 }
 185
 186 static inline bool
 187 st_object_is_string (st_oop object)
 188 {
 189     return st_object_class (object) == ST_STRING_CLASS;
 190 }
 191
 192 static inline bool
 193 st_object_is_array (st_oop object)
 194 {
 195     return st_object_class (object) == ST_ARRAY_CLASS;
 196 }
 197
 198 static inline bool
 199 st_object_is_byte_array (st_oop object)
 200 {
 201     return st_object_class (object) == ST_BYTE_ARRAY_CLASS;
 202 }
 203
 204 static inline bool
 205 st_object_is_float (st_oop object)
 206 {
 207     return st_object_class (object) == ST_FLOAT_CLASS;
 208 }
 209
 210 #endif /* __ST_OBJECT_H__ */