include/c-chunk.h

   1 /* Copyright (C) 1999-2008 Henry Cejtin, Matthew Fluet, Suresh
   2  *    Jagannathan, and Stephen Weeks.
   3  * Copyright (C) 1997-2000 NEC Research Institute.
   4  *
   5  * MLton is released under a BSD-style license.
   6  * See the file MLton-LICENSE for details.
   7  */
   8
   9 #ifndef _C_CHUNK_H_
  10 #define _C_CHUNK_H_
  11
  12 #include <stdio.h>
  13
  14 #include "ml-types.h"
  15 #include "c-types.h"
  16 #include "c-common.h"
  17
  18 #ifndef TRUE
  19 #define TRUE 1
  20 #endif
  21
  22 #ifndef FALSE
  23 #define FALSE 0
  24 #endif
  25
  26 #ifndef DEBUG_CCODEGEN
  27 #define DEBUG_CCODEGEN FALSE
  28 #endif
  29
  30 #define GCState ((Pointer)&gcState)
  31 #define ExnStack *(size_t*)(GCState + ExnStackOffset)
  32 #define FrontierMem *(Pointer*)(GCState + FrontierOffset)
  33 #define Frontier frontier
  34 #define StackBottom *(Pointer*)(GCState + StackBottomOffset)
  35 #define StackTopMem *(Pointer*)(GCState + StackTopOffset)
  36 #define StackTop stackTop
  37
  38 /* ------------------------------------------------- */
  39 /*                      Memory                       */
  40 /* ------------------------------------------------- */
  41
  42 #define C(ty, x) (*(ty*)(x))
  43 #define G(ty, i) (global##ty [i])
  44 #define GPNR(i) G(ObjptrNonRoot, i)
  45 #define O(ty, b, o) (*(ty*)((b) + (o)))
  46 #define X(ty, b, i, s, o) (*(ty*)((b) + ((i) * (s)) + (o)))
  47 #define S(ty, i) *(ty*)(StackTop + (i))
  48
  49 /* ------------------------------------------------- */
  50 /*                       Tests                       */
  51 /* ------------------------------------------------- */
  52
  53 #define IsInt(p) (0x3 & (int)(p))
  54
  55 #define BZ(x, l)                                                        \
  56         do {                                                            \
  57                 if (DEBUG_CCODEGEN)                                     \
  58                         fprintf (stderr, "%s:%d: BZ(%d, %s)\n", \
  59                                         __FILE__, __LINE__, (x), #l);   \
  60                 if (0 == (x)) goto l;                                   \
  61         } while (0)
  62
  63 #define BNZ(x, l)                                                       \
  64         do {                                                            \
  65                 if (DEBUG_CCODEGEN)                                     \
  66                         fprintf (stderr, "%s:%d: BNZ(%d, %s)\n",        \
  67                                         __FILE__, __LINE__, (x), #l);   \
  68                 if (x) goto l;                                          \
  69         } while (0)
  70
  71 #define FlushFrontier()                         \
  72         do {                                    \
  73                 FrontierMem = Frontier;         \
  74         } while (0)
  75
  76 #define FlushStackTop()                         \
  77         do {                                    \
  78                 StackTopMem = StackTop;         \
  79         } while (0)
  80
  81 #define CacheFrontier()                         \
  82         do {                                    \
  83                 Frontier = FrontierMem;         \
  84         } while (0)
  85
  86 #define CacheStackTop()                         \
  87         do {                                    \
  88                 StackTop = StackTopMem;         \
  89         } while (0)
  90
  91 /* ------------------------------------------------- */
  92 /*                       Chunk                       */
  93 /* ------------------------------------------------- */
  94
  95 #if (defined (__sun__) && defined (REGISTER_FRONTIER_STACKTOP))
  96 #define Chunk(n)                                                \
  97         DeclareChunk(n) {                                       \
  98                 struct cont cont;                               \
  99                 register unsigned int frontier asm("g5");       \
 100                 uintptr_t l_nextFun = nextFun;                  \
 101                 register unsigned int stackTop asm("g6");
 102 #else
 103 #define Chunk(n)                                \
 104         DeclareChunk(n) {                       \
 105                 struct cont cont;               \
 106                 Pointer frontier;               \
 107                 uintptr_t l_nextFun = nextFun;  \
 108                 Pointer stackTop;
 109 #endif
 110
 111 #define ChunkSwitch(n)                                                  \
 112                 if (DEBUG_CCODEGEN)                                     \
 113                         fprintf (stderr, "%s:%d: entering chunk %d  l_nextFun = %d\n", \
 114                                         __FILE__, __LINE__, n, (int)l_nextFun); \
 115                 CacheFrontier();                                        \
 116                 CacheStackTop();                                        \
 117                 while (1) {                                             \
 118                 top:                                                    \
 119                 switch (l_nextFun) {
 120
 121 #define EndChunk                                                        \
 122                 default:                                                \
 123                         /* interchunk return */                         \
 124                         nextFun = l_nextFun;                            \
 125                         cont.nextChunk = (void*)nextChunks[nextFun];    \
 126                         leaveChunk:                                     \
 127                                 FlushFrontier();                        \
 128                                 FlushStackTop();                        \
 129                                 return cont;                            \
 130                 } /* end switch (l_nextFun) */                          \
 131                 } /* end while (1) */                                   \
 132         } /* end chunk */
 133
 134 /* ------------------------------------------------- */
 135 /*                Calling SML from C                 */
 136 /* ------------------------------------------------- */
 137
 138 #define Thread_returnToC()                                              \
 139         do {                                                            \
 140                 if (DEBUG_CCODEGEN)                                     \
 141                         fprintf (stderr, "%s:%d: Thread_returnToC()\n", \
 142                                         __FILE__, __LINE__);            \
 143                 returnToC = TRUE;                                       \
 144                 return cont;                                            \
 145         } while (0)
 146
 147 /* ------------------------------------------------- */
 148 /*                      farJump                      */
 149 /* ------------------------------------------------- */
 150
 151 #define FarJump(n, l)                           \
 152         do {                                    \
 153                 PrepFarJump(n, l);              \
 154                 goto leaveChunk;                \
 155         } while (0)
 156
 157 /* ------------------------------------------------- */
 158 /*                       Stack                       */
 159 /* ------------------------------------------------- */
 160
 161 #define Push(bytes)                                                     \
 162         do {                                                            \
 163                 if (DEBUG_CCODEGEN)                                     \
 164                         fprintf (stderr, "%s:%d: Push (%d)\n",          \
 165                                         __FILE__, __LINE__, bytes);     \
 166                 StackTop += (bytes);                                    \
 167         } while (0)
 168
 169 #define Return()                                                                \
 170         do {                                                                    \
 171                 l_nextFun = *(uintptr_t*)(StackTop - sizeof(void*));            \
 172                 if (DEBUG_CCODEGEN)                                             \
 173                         fprintf (stderr, "%s:%d: Return()  l_nextFun = %d\n",   \
 174                                         __FILE__, __LINE__, (int)l_nextFun);    \
 175                 goto top;                                                       \
 176         } while (0)
 177
 178 #define Raise()                                                                 \
 179         do {                                                                    \
 180                 if (DEBUG_CCODEGEN)                                             \
 181                         fprintf (stderr, "%s:%d: Raise\n",                      \
 182                                         __FILE__, __LINE__);                    \
 183                 StackTop = StackBottom + ExnStack;                              \
 184                 Return();                                                       \
 185         } while (0)                                                             \
 186
 187 /* ------------------------------------------------- */
 188 /*                       Primitives                  */
 189 /* ------------------------------------------------- */
 190
 191 #ifndef MLTON_CODEGEN_STATIC_INLINE
 192 #define MLTON_CODEGEN_STATIC_INLINE static inline
 193 #endif
 194 /* Declare inlined math functions, since <math.h> isn't included.
 195  */
 196 #ifndef MLTON_CODEGEN_MATHFN
 197 #define MLTON_CODEGEN_MATHFN(decl) decl
 198 #endif
 199 /* WordS<N>_quot and WordS<N>_rem can't be inlined with the C-codegen,
 200  * because the gcc optimizer sometimes produces incorrect results when
 201  * one of the arguments is a constant.
 202  */
 203 #ifndef MLTON_CODEGEN_WORDSQUOTREM
 204 #define MLTON_CODEGEN_WORDSQUOTREM(func) PRIVATE
 205 #endif
 206 #ifndef MLTON_CODEGEN_WORDSQUOTREM_IMPL
 207 #define MLTON_CODEGEN_WORDSQUOTREM_IMPL(func)
 208 #endif
 209 /* Declare memcpy, since <string.h> isn't included.
 210  */
 211 #ifndef MLTON_CODEGEN_MEMCPY
 212 #define MLTON_CODEGEN_MEMCPY(decl)
 213 #endif
 214 MLTON_CODEGEN_MEMCPY(void * memcpy(void *, const void*, size_t);)
 215 #include "basis-ffi.h"
 216 #include "basis/coerce.h"
 217 #include "basis/cpointer.h"
 218 #include "basis/Real/Real-ops.h"
 219 #include "basis/Real/Math-fns.h"
 220 #include "basis/Word/Word-ops.h"
 221 #include "basis/Word/Word-consts.h"
 222 #include "basis/Word/Word-check.h"
 223
 224 /* ------------------------------------------------- */
 225 /*                        Word                       */
 226 /* ------------------------------------------------- */
 227
 228 #define WordS_addCheckCX(size, dst, cW, xW, l)                  \
 229   do {                                                          \
 230     WordS##size c = cW;                                         \
 231     WordS##size x = xW;                                         \
 232     WordS_addCheckBodyCX(size, c, x, goto l, dst = c + x);      \
 233   } while (0)
 234 #define WordS8_addCheckCX(dst, c, x, l) WordS_addCheckCX(8, dst, c, x, l)
 235 #define WordS16_addCheckCX(dst, c, x, l) WordS_addCheckCX(16, dst, c, x, l)
 236 #define WordS32_addCheckCX(dst, c, x, l) WordS_addCheckCX(32, dst, c, x, l)
 237 #define WordS64_addCheckCX(dst, c, x, l) WordS_addCheckCX(64, dst, c, x, l)
 238
 239 #define WordS8_addCheckXC(dst, x, c, l) WordS8_addCheckCX(dst, c, x, l)
 240 #define WordS16_addCheckXC(dst, x, c, l) WordS16_addCheckCX(dst, c, x, l)
 241 #define WordS32_addCheckXC(dst, x, c, l) WordS32_addCheckCX(dst, c, x, l)
 242 #define WordS64_addCheckXC(dst, x, c, l) WordS64_addCheckCX(dst, c, x, l)
 243
 244 #define WordS8_addCheck WordS8_addCheckXC
 245 #define WordS16_addCheck WordS16_addCheckXC
 246 #define WordS32_addCheck WordS32_addCheckXC
 247 #define WordS64_addCheck WordS64_addCheckXC
 248
 249
 250 #define WordU_addCheckCX(size, dst, cW, xW, l)                  \
 251   do {                                                          \
 252     WordU##size c = cW;                                         \
 253     WordU##size x = xW;                                         \
 254     WordU_addCheckBodyCX(size, c, x, goto l, dst = c + x);      \
 255   } while (0)
 256 #define WordU8_addCheckCX(dst, c, x, l) WordU_addCheckCX(8, dst, c, x, l)
 257 #define WordU16_addCheckCX(dst, c, x, l) WordU_addCheckCX(16, dst, c, x, l)
 258 #define WordU32_addCheckCX(dst, c, x, l) WordU_addCheckCX(32, dst, c, x, l)
 259 #define WordU64_addCheckCX(dst, c, x, l) WordU_addCheckCX(64, dst, c, x, l)
 260
 261 #define WordU8_addCheckXC(dst, x, c, l) WordU8_addCheckCX(dst, c, x, l)
 262 #define WordU16_addCheckXC(dst, x, c, l) WordU16_addCheckCX(dst, c, x, l)
 263 #define WordU32_addCheckXC(dst, x, c, l) WordU32_addCheckCX(dst, c, x, l)
 264 #define WordU64_addCheckXC(dst, x, c, l) WordU64_addCheckCX(dst, c, x, l)
 265
 266 #define WordU8_addCheck WordU8_addCheckXC
 267 #define WordU16_addCheck WordU16_addCheckXC
 268 #define WordU32_addCheck WordU32_addCheckXC
 269 #define WordU64_addCheck WordU64_addCheckXC
 270
 271
 272 #define WordS_negCheck(size, dst, xW, l)                \
 273   do {                                                  \
 274     WordS##size x = xW;                                 \
 275     WordS_negCheckBody(size, x, goto l, dst = -x);      \
 276   } while (0)
 277 #define Word8_negCheck(dst, x, l) WordS_negCheck(8, dst, x, l)
 278 #define Word16_negCheck(dst, x, l) WordS_negCheck(16, dst, x, l)
 279 #define Word32_negCheck(dst, x, l) WordS_negCheck(32, dst, x, l)
 280 #define Word64_negCheck(dst, x, l) WordS_negCheck(64, dst, x, l)
 281
 282
 283 #define WordS_subCheckCX(size, dst, cW, xW, l)                  \
 284   do {                                                          \
 285     WordS##size c = cW;                                         \
 286     WordS##size x = xW;                                         \
 287     WordS_subCheckBodyCX(size, c, x, goto l, dst = c - x);      \
 288   } while (0)
 289 #define WordS8_subCheckCX(dst, c, x, l) WordS_subCheckCX(8, dst, c, x, l)
 290 #define WordS16_subCheckCX(dst, c, x, l) WordS_subCheckCX(16, dst, c, x, l)
 291 #define WordS32_subCheckCX(dst, c, x, l) WordS_subCheckCX(32, dst, c, x, l)
 292 #define WordS64_subCheckCX(dst, c, x, l) WordS_subCheckCX(64, dst, c, x, l)
 293
 294 #define WordS_subCheckXC(size, dst, xW, cW, l)                  \
 295   do {                                                          \
 296     WordS##size x = xW;                                         \
 297     WordS##size c = cW;                                         \
 298     WordS_subCheckBodyXC(size, x, c, goto l, dst = x - c);      \
 299   } while (0)
 300 #define WordS8_subCheckXC(dst, x, c, l) WordS_subCheckXC(8, dst, x, c, l)
 301 #define WordS16_subCheckXC(dst, x, c, l) WordS_subCheckXC(16, dst, x, c, l)
 302 #define WordS32_subCheckXC(dst, x, c, l) WordS_subCheckXC(32, dst, x, c, l)
 303 #define WordS64_subCheckXC(dst, x, c, l) WordS_subCheckXC(64, dst, x, c, l)
 304
 305 #define WordS8_subCheck WordS8_subCheckXC
 306 #define WordS16_subCheck WordS16_subCheckXC
 307 #define WordS32_subCheck WordS32_subCheckXC
 308 #define WordS64_subCheck WordS64_subCheckXC
 309
 310
 311 #define WordS_mulCheck(size, dst, xW, yW, l)                    \
 312   do {                                                          \
 313     WordS##size x = xW;                                         \
 314     WordS##size y = yW;                                         \
 315     WordS_mulCheckBody(size, x, y, goto l, dst = x * y);        \
 316   } while (0)
 317 #define WordS8_mulCheck(dst, x, y, l) WordS_mulCheck(8, dst, x, y, l)
 318 #define WordS16_mulCheck(dst, x, y, l) WordS_mulCheck(16, dst, x, y, l)
 319 #define WordS32_mulCheck(dst, x, y, l) WordS_mulCheck(32, dst, x, y, l)
 320 #define WordS64_mulCheck(dst, x, y, l) WordS_mulCheck(64, dst, x, y, l)
 321
 322 #define WordU_mulCheck(size, dst, xW, yW, l)                    \
 323   do {                                                          \
 324     WordU##size x = xW;                                         \
 325     WordU##size y = yW;                                         \
 326     WordU_mulCheckBody(size, x, y, goto l, dst = x * y);        \
 327   } while (0)
 328 #define WordU8_mulCheck(dst, x, y, l) WordU_mulCheck(8, dst, x, y, l)
 329 #define WordU16_mulCheck(dst, x, y, l) WordU_mulCheck(16, dst, x, y, l)
 330 #define WordU32_mulCheck(dst, x, y, l) WordU_mulCheck(32, dst, x, y, l)
 331 #define WordU64_mulCheck(dst, x, y, l) WordU_mulCheck(64, dst, x, y, l)
 332
 333 #endif /* #ifndef _C_CHUNK_H_ */