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