libguile/objcodes.c

   1 /* Copyright (C) 2001, 2009 Free Software Foundation, Inc.
   2  *
   3  * This library is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU Lesser General Public License
   5  * as published by the Free Software Foundation; either version 3 of
   6  * the License, or (at your option) any later version.
   7  *
   8  * This library is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * Lesser General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public
  14  * License along with this library; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  16  * 02110-1301 USA
  17  */
  18
  19 #if HAVE_CONFIG_H
  20 #  include <config.h>
  21 #endif
  22
  23 #include <string.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <sys/mman.h>
  27 #include <sys/stat.h>
  28 #include <sys/types.h>
  29 #include <assert.h>
  30
  31 #include "_scm.h"
  32 #include "vm-bootstrap.h"
  33 #include "programs.h"
  34 #include "objcodes.h"
  35
  36 /* SCM_OBJCODE_COOKIE is defined in _scm.h */
  37 /* The length of the header must be a multiple of 8 bytes.  */
  38 verify (((sizeof (SCM_OBJCODE_COOKIE) - 1) & 7) == 0);
  39
  40 \f
  41 /*
  42  * Objcode type
  43  */
  44
  45 scm_t_bits scm_tc16_objcode;
  46
  47 static SCM
  48 make_objcode_by_mmap (int fd)
  49 #define FUNC_NAME "make_objcode_by_mmap"
  50 {
  51   int ret;
  52   char *addr;
  53   struct stat st;
  54   SCM sret = SCM_BOOL_F;
  55   struct scm_objcode *data;
  56
  57   ret = fstat (fd, &st);
  58   if (ret < 0)
  59     SCM_SYSERROR;
  60
  61   if (st.st_size <= sizeof (struct scm_objcode) + strlen (SCM_OBJCODE_COOKIE))
  62     scm_misc_error (FUNC_NAME, "object file too small (~a bytes)",
  63                     scm_list_1 (SCM_I_MAKINUM (st.st_size)));
  64
  65   addr = mmap (0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
  66   if (addr == MAP_FAILED)
  67     {
  68       (void) close (fd);
  69       SCM_SYSERROR;
  70     }
  71
  72   if (memcmp (addr, SCM_OBJCODE_COOKIE, strlen (SCM_OBJCODE_COOKIE)))
  73     {
  74       SCM args = scm_list_1 (scm_from_locale_stringn
  75                              (addr, strlen (SCM_OBJCODE_COOKIE)));
  76       (void) close (fd);
  77       (void) munmap (addr, st.st_size);
  78       scm_misc_error (FUNC_NAME, "bad header on object file: ~s", args);
  79     }
  80
  81   data = (struct scm_objcode*)(addr + strlen (SCM_OBJCODE_COOKIE));
  82
  83   if (data->len + data->metalen != (st.st_size - sizeof (*data) - strlen (SCM_OBJCODE_COOKIE)))
  84     {
  85       (void) close (fd);
  86       (void) munmap (addr, st.st_size);
  87       scm_misc_error (FUNC_NAME, "bad length header (~a, ~a)",
  88                       scm_list_2 (scm_from_size_t (st.st_size),
  89                                   scm_from_uint32 (sizeof (*data) + data->len
  90                                                    + data->metalen)));
  91     }
  92
  93   SCM_NEWSMOB3 (sret, scm_tc16_objcode, addr + strlen (SCM_OBJCODE_COOKIE),
  94                 SCM_PACK (SCM_BOOL_F), fd);
  95   SCM_SET_SMOB_FLAGS (sret, SCM_F_OBJCODE_IS_MMAP);
  96
  97   /* FIXME: we leak ourselves and the file descriptor. but then again so does
  98      dlopen(). */
  99   return scm_permanent_object (sret);
 100 }
 101 #undef FUNC_NAME
 102
 103 SCM
 104 scm_c_make_objcode_slice (SCM parent, const scm_t_uint8 *ptr)
 105 #define FUNC_NAME "make-objcode-slice"
 106 {
 107   const struct scm_objcode *data, *parent_data;
 108   SCM ret;
 109
 110   SCM_VALIDATE_OBJCODE (1, parent);
 111   parent_data = SCM_OBJCODE_DATA (parent);
 112
 113   if (ptr < parent_data->base
 114       || ptr >= (parent_data->base + parent_data->len + parent_data->metalen
 115                  - sizeof (struct scm_objcode)))
 116     scm_misc_error (FUNC_NAME, "offset out of bounds (~a vs ~a + ~a + ~a)",
 117                     scm_list_4 (scm_from_ulong ((unsigned long)ptr),
 118                                 scm_from_ulong ((unsigned long)parent_data->base),
 119                                 scm_from_uint32 (parent_data->len),
 120                                 scm_from_uint32 (parent_data->metalen)));
 121
 122 #ifdef __GNUC__ /* we need `__alignof__' */
 123   /* Make sure bytecode for the objcode-meta is suitable aligned.  Failing to
 124      do so leads to SIGBUS/SIGSEGV on some arches (e.g., SPARC).  */
 125   assert ((((scm_t_bits) ptr) & (__alignof__ (struct scm_objcode) - 1UL)) == 0);
 126 #endif
 127
 128   data = (struct scm_objcode*)ptr;
 129   if (data->base + data->len + data->metalen > parent_data->base + parent_data->len + parent_data->metalen)
 130     abort ();
 131
 132   SCM_NEWSMOB2 (ret, scm_tc16_objcode, data, parent);
 133   SCM_SET_SMOB_FLAGS (ret, SCM_F_OBJCODE_IS_SLICE);
 134   return ret;
 135 }
 136 #undef FUNC_NAME
 137
 138 \f
 139 /*
 140  * Scheme interface
 141  */
 142
 143 SCM_DEFINE (scm_objcode_p, "objcode?", 1, 0, 0,
 144             (SCM obj),
 145             "")
 146 #define FUNC_NAME s_scm_objcode_p
 147 {
 148   return SCM_BOOL (SCM_OBJCODE_P (obj));
 149 }
 150 #undef FUNC_NAME
 151
 152 SCM_DEFINE (scm_objcode_meta, "objcode-meta", 1, 0, 0,
 153             (SCM objcode),
 154             "")
 155 #define FUNC_NAME s_scm_objcode_meta
 156 {
 157   SCM_VALIDATE_OBJCODE (1, objcode);
 158
 159   if (SCM_OBJCODE_META_LEN (objcode) == 0)
 160     return SCM_BOOL_F;
 161   else
 162     return scm_c_make_objcode_slice (objcode, (SCM_OBJCODE_BASE (objcode)
 163                                                + SCM_OBJCODE_LEN (objcode)));
 164 }
 165 #undef FUNC_NAME
 166
 167 SCM_DEFINE (scm_bytecode_to_objcode, "bytecode->objcode", 1, 0, 0,
 168             (SCM bytecode),
 169             "")
 170 #define FUNC_NAME s_scm_bytecode_to_objcode
 171 {
 172   size_t size;
 173   ssize_t increment;
 174   scm_t_array_handle handle;
 175   const scm_t_uint8 *c_bytecode;
 176   struct scm_objcode *data;
 177   SCM objcode;
 178
 179   if (scm_is_false (scm_u8vector_p (bytecode)))
 180     scm_wrong_type_arg (FUNC_NAME, 1, bytecode);
 181
 182   c_bytecode = scm_u8vector_elements (bytecode, &handle, &size, &increment);
 183   data = (struct scm_objcode*)c_bytecode;
 184   SCM_NEWSMOB2 (objcode, scm_tc16_objcode, data, bytecode);
 185   scm_array_handle_release (&handle);
 186
 187   SCM_ASSERT_RANGE (0, bytecode, size >= sizeof(struct scm_objcode));
 188   if (data->len + data->metalen != (size - sizeof (*data)))
 189     scm_misc_error (FUNC_NAME, "bad u8vector size (~a != ~a)",
 190                     scm_list_2 (scm_from_size_t (size),
 191                                 scm_from_uint32 (sizeof (*data) + data->len + data->metalen)));
 192   assert (increment == 1);
 193   SCM_SET_SMOB_FLAGS (objcode, SCM_F_OBJCODE_IS_U8VECTOR);
 194
 195   /* foolishly, we assume that as long as bytecode is around, that c_bytecode
 196      will be of the same length; perhaps a bad assumption? */
 197
 198   return objcode;
 199 }
 200 #undef FUNC_NAME
 201
 202 SCM_DEFINE (scm_load_objcode, "load-objcode", 1, 0, 0,
 203             (SCM file),
 204             "")
 205 #define FUNC_NAME s_scm_load_objcode
 206 {
 207   int fd;
 208   char *c_file;
 209
 210   SCM_VALIDATE_STRING (1, file);
 211
 212   c_file = scm_to_locale_string (file);
 213   fd = open (c_file, O_RDONLY);
 214   free (c_file);
 215   if (fd < 0) SCM_SYSERROR;
 216
 217   return make_objcode_by_mmap (fd);
 218 }
 219 #undef FUNC_NAME
 220
 221 SCM_DEFINE (scm_objcode_to_bytecode, "objcode->bytecode", 1, 0, 0,
 222             (SCM objcode),
 223             "")
 224 #define FUNC_NAME s_scm_objcode_to_bytecode
 225 {
 226   scm_t_uint8 *u8vector;
 227   scm_t_uint32 len;
 228
 229   SCM_VALIDATE_OBJCODE (1, objcode);
 230
 231   len = sizeof(struct scm_objcode) + SCM_OBJCODE_TOTAL_LEN (objcode);
 232
 233   u8vector = scm_malloc (len);
 234   memcpy (u8vector, SCM_OBJCODE_DATA (objcode), len);
 235
 236   return scm_take_u8vector (u8vector, len);
 237 }
 238 #undef FUNC_NAME
 239
 240 SCM_DEFINE (scm_write_objcode, "write-objcode", 2, 0, 0,
 241             (SCM objcode, SCM port),
 242             "")
 243 #define FUNC_NAME s_scm_write_objcode
 244 {
 245   SCM_VALIDATE_OBJCODE (1, objcode);
 246   SCM_VALIDATE_OUTPUT_PORT (2, port);
 247
 248   scm_c_write (port, SCM_OBJCODE_COOKIE, strlen (SCM_OBJCODE_COOKIE));
 249   scm_c_write (port, SCM_OBJCODE_DATA (objcode),
 250                sizeof (struct scm_objcode) + SCM_OBJCODE_TOTAL_LEN (objcode));
 251
 252   return SCM_UNSPECIFIED;
 253 }
 254 #undef FUNC_NAME
 255
 256 \f
 257 void
 258 scm_bootstrap_objcodes (void)
 259 {
 260   scm_tc16_objcode = scm_make_smob_type ("objcode", 0);
 261   scm_c_register_extension ("libguile", "scm_init_objcodes",
 262                             (scm_t_extension_init_func)scm_init_objcodes, NULL);
 263 }
 264
 265 /* Before, we used __BYTE_ORDER, but that is not defined on all
 266    systems. So punt and use automake, PDP endianness be damned. */
 267 #ifdef WORDS_BIGENDIAN
 268 #define SCM_BYTE_ORDER 4321
 269 #else
 270 #define SCM_BYTE_ORDER 1234
 271 #endif
 272
 273 void
 274 scm_init_objcodes (void)
 275 {
 276   scm_bootstrap_vm ();
 277
 278 #ifndef SCM_MAGIC_SNARFER
 279 #include "libguile/objcodes.x"
 280 #endif
 281
 282   scm_c_define ("word-size", scm_from_size_t (sizeof(SCM)));
 283   scm_c_define ("byte-order", scm_from_uint16 (SCM_BYTE_ORDER));
 284 }
 285
 286 /*
 287   Local Variables:
 288   c-file-style: "gnu"
 289   End:
 290 */