69ed4aee61
almost all uses of this are interactive, except for deepSeq. deepSeq is going to be expensive and rare enough to not care much about, and Value::determinePos should usually be cheap enough to not be too much of a burden in any case.
142 lines
3.6 KiB
C++
142 lines
3.6 KiB
C++
#pragma once
|
|
///@file
|
|
|
|
#include "eval.hh"
|
|
|
|
namespace nix {
|
|
|
|
/**
|
|
* Note: Various places expect the allocated memory to be zeroed.
|
|
*/
|
|
[[gnu::always_inline]]
|
|
inline void * allocBytes(size_t n)
|
|
{
|
|
void * p;
|
|
#if HAVE_BOEHMGC
|
|
p = GC_MALLOC(n);
|
|
#else
|
|
p = calloc(n, 1);
|
|
#endif
|
|
if (!p) throw std::bad_alloc();
|
|
return p;
|
|
}
|
|
|
|
|
|
[[gnu::always_inline]]
|
|
Value * EvalState::allocValue()
|
|
{
|
|
#if HAVE_BOEHMGC
|
|
/* We use the boehm batch allocator to speed up allocations of Values (of which there are many).
|
|
GC_malloc_many returns a linked list of objects of the given size, where the first word
|
|
of each object is also the pointer to the next object in the list. This also means that we
|
|
have to explicitly clear the first word of every object we take. */
|
|
if (!*valueAllocCache) {
|
|
*valueAllocCache = GC_malloc_many(sizeof(Value));
|
|
if (!*valueAllocCache) throw std::bad_alloc();
|
|
}
|
|
|
|
/* GC_NEXT is a convenience macro for accessing the first word of an object.
|
|
Take the first list item, advance the list to the next item, and clear the next pointer. */
|
|
void * p = *valueAllocCache;
|
|
*valueAllocCache = GC_NEXT(p);
|
|
GC_NEXT(p) = nullptr;
|
|
#else
|
|
void * p = allocBytes(sizeof(Value));
|
|
#endif
|
|
|
|
nrValues++;
|
|
return (Value *) p;
|
|
}
|
|
|
|
|
|
[[gnu::always_inline]]
|
|
Env & EvalState::allocEnv(size_t size)
|
|
{
|
|
nrEnvs++;
|
|
nrValuesInEnvs += size;
|
|
|
|
Env * env;
|
|
|
|
#if HAVE_BOEHMGC
|
|
if (size == 1) {
|
|
/* see allocValue for explanations. */
|
|
if (!*env1AllocCache) {
|
|
*env1AllocCache = GC_malloc_many(sizeof(Env) + sizeof(Value *));
|
|
if (!*env1AllocCache) throw std::bad_alloc();
|
|
}
|
|
|
|
void * p = *env1AllocCache;
|
|
*env1AllocCache = GC_NEXT(p);
|
|
GC_NEXT(p) = nullptr;
|
|
env = (Env *) p;
|
|
} else
|
|
#endif
|
|
env = (Env *) allocBytes(sizeof(Env) + size * sizeof(Value *));
|
|
|
|
env->type = Env::Plain;
|
|
|
|
/* We assume that env->values has been cleared by the allocator; maybeThunk() and lookupVar fromWith expect this. */
|
|
|
|
return *env;
|
|
}
|
|
|
|
|
|
void EvalState::forceValue(Value & v, const PosIdx pos)
|
|
{
|
|
if (v.isThunk()) {
|
|
Env * env = v.thunk.env;
|
|
Expr * expr = v.thunk.expr;
|
|
try {
|
|
v.mkBlackhole();
|
|
//checkInterrupt();
|
|
expr->eval(*this, *env, v);
|
|
} catch (...) {
|
|
v.mkThunk(env, expr);
|
|
throw;
|
|
}
|
|
}
|
|
else if (v.isApp()) {
|
|
try {
|
|
callFunction(*v.app.left, *v.app.right, v, noPos);
|
|
} catch (InfiniteRecursionError & e) {
|
|
// only one black hole can *throw* in any given eval stack so we need not
|
|
// check whether the position is set already.
|
|
if (v.isBlackhole())
|
|
e.err.errPos = positions[pos];
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
[[gnu::always_inline]]
|
|
inline void EvalState::forceAttrs(Value & v, const PosIdx pos, std::string_view errorCtx)
|
|
{
|
|
forceAttrs(v, [&]() { return pos; }, errorCtx);
|
|
}
|
|
|
|
|
|
template <typename Callable>
|
|
[[gnu::always_inline]]
|
|
inline void EvalState::forceAttrs(Value & v, Callable getPos, std::string_view errorCtx)
|
|
{
|
|
PosIdx pos = getPos();
|
|
forceValue(v, pos);
|
|
if (v.type() != nAttrs) {
|
|
error("value is %1% while a set was expected", showType(v)).withTrace(pos, errorCtx).debugThrow<TypeError>();
|
|
}
|
|
}
|
|
|
|
|
|
[[gnu::always_inline]]
|
|
inline void EvalState::forceList(Value & v, const PosIdx pos, std::string_view errorCtx)
|
|
{
|
|
forceValue(v, pos);
|
|
if (!v.isList()) {
|
|
error("value is %1% while a list was expected", showType(v)).withTrace(pos, errorCtx).debugThrow<TypeError>();
|
|
}
|
|
}
|
|
|
|
|
|
}
|