void emitIssetS(HTS& env) {
auto const ssaPropName = topC(env, BCSPOffset{1});
if (!ssaPropName->isA(Type::Str)) {
PUNT(IssetS-PropNameNotString);
}
auto const ssaCls = popA(env);
auto const ret = cond(
env,
0,
[&] (Block* taken) {
auto propAddr = ldClsPropAddr(env, ssaCls, ssaPropName, false);
return gen(env, CheckNonNull, taken, propAddr);
},
[&] (SSATmp* ptr) { // Next: property or global exists
return gen(env, IsNTypeMem, Type::Null, gen(env, UnboxPtr, ptr));
},
[&] { // Taken: LdClsPropAddr* returned Nullptr because it isn't defined
return cns(env, false);
}
);
destroyName(env, ssaPropName);
push(env, ret);
}
// Memory Object APIs
cl_mem
clCreateBuffer(cl_context d_context,
cl_mem_flags flags,
size_t size,
void * host_ptr,
cl_int * errcode_ret)
{
cl_int dummy_errcode;
auto context = pobj(d_context);
if (!errcode_ret)
errcode_ret = &dummy_errcode;
if (!context->isA(Coal::Object::T_Context))
{
*errcode_ret = CL_INVALID_CONTEXT;
return 0;
}
*errcode_ret = CL_SUCCESS;
Coal::Buffer *buf = new Coal::Buffer(context, size, host_ptr, flags,
errcode_ret);
if (*errcode_ret != CL_SUCCESS || (*errcode_ret = buf->init()) != CL_SUCCESS)
{
delete buf;
return 0;
}
return desc(buf);
}
int AbstractArray::isEqual( const Object& obj ) const
{
PRECONDITION( isA() == obj.isA() );
AbstractArray& test = (AbstractArray&)obj;
if( lowerBound() != test.lowerBound() ||
upperBound() != test.upperBound()
)
return 0;
ContainerIterator& iter1 = initIterator();
ContainerIterator& iter2 = test.initIterator();
while( iter1 && iter2 )
if( iter1.current() != iter2.current() )
{
delete &iter1;
delete &iter2;
return 0;
}
else
{
iter1++;
iter2++;
}
delete &iter1;
delete &iter2;
return 1;
}
cl_int
clGetSupportedImageFormats(cl_context d_context,
cl_mem_flags flags,
cl_mem_object_type image_type,
cl_uint num_entries,
cl_image_format * image_formats,
cl_uint * num_image_formats)
{
auto context = pobj(d_context);
if (!context->isA(Coal::Object::T_Context))
return CL_INVALID_CONTEXT;
(void) flags;
(void) image_type;
if (!num_entries && image_formats)
return CL_INVALID_VALUE;
if (image_formats)
{
std::memcpy(image_formats, supported_formats,
MIN(num_entries * sizeof(cl_image_format),
sizeof(supported_formats)));
}
if (num_image_formats)
*num_image_formats = sizeof(supported_formats) / sizeof(cl_image_format);
return CL_SUCCESS;
}
cl_int
clReleaseKernel(cl_kernel d_kernel)
{
auto kernel = pobj(d_kernel);
if (!kernel->isA(Coal::Object::T_Kernel))
return CL_INVALID_KERNEL;
if (kernel->dereference())
{
Coal::Program *p =(Coal::Program *)kernel->parent();
for (size_t i=0; i < p->kernelList.size(); i++)
{
if (p->kernelList[i]->p_name.compare(kernel->p_name) == 0)
{
p->kernelReleasedList.push_back(p->kernelList[i]);
p->kernelList.erase(p->kernelList.begin() + i);
// BUG: TAG
// For some odd reason when we delete this, we're corrupting then inside of some kernel objects
//delete kernel;
}
}
}
return CL_SUCCESS;
}
bool UPolyItem::match(const char * wildname)
{
const char * p1;
bool result;
int n;
//
if (true)
{
result = wildcmp(wildname, name);
}
else
{
p1 = strchr(wildname, '*');
if (p1 != NULL)
{
n = p1 - wildname;
if ((unsigned int)n <= strlen(name))
result = strncasecmp(name, wildname, n) == 0;
else
result = false;
}
else
result = isA(wildname);
}
return result;
}
void emitEmptyS(IRGS& env) {
auto const ssaPropName = topC(env, BCSPOffset{1});
if (!ssaPropName->isA(TStr)) {
PUNT(EmptyS-PropNameNotString);
}
auto const ssaCls = popA(env);
auto const ret = cond(
env,
[&] (Block* taken) {
auto propAddr = ldClsPropAddr(env, ssaCls, ssaPropName, false);
return gen(env, CheckNonNull, taken, propAddr);
},
[&] (SSATmp* ptr) {
auto const unbox = gen(env, UnboxPtr, ptr);
auto const val = gen(env, LdMem, unbox->type().deref(), unbox);
return gen(env, XorBool, gen(env, ConvCellToBool, val), cns(env, true));
},
[&] { // Taken: LdClsPropAddr* returned Nullptr because it isn't defined
return cns(env, true);
});
destroyName(env, ssaPropName);
push(env, ret);
}
void emitCastArray(HTS& env) {
auto const src = popC(env);
push(
env,
[&] {
if (src->isA(Type::Arr)) return src;
if (src->isA(Type::Null)) return cns(env, staticEmptyArray());
if (src->isA(Type::Bool)) return gen(env, ConvBoolToArr, src);
if (src->isA(Type::Dbl)) return gen(env, ConvDblToArr, src);
if (src->isA(Type::Int)) return gen(env, ConvIntToArr, src);
if (src->isA(Type::Str)) return gen(env, ConvStrToArr, src);
if (src->isA(Type::Obj)) return gen(env, ConvObjToArr, src);
return gen(env, ConvCellToArr, src);
}()
);
}
// Sampler APIs
cl_sampler
clCreateSampler(cl_context d_context,
cl_bool normalized_coords,
cl_addressing_mode addressing_mode,
cl_filter_mode filter_mode,
cl_int * errcode_ret)
{
cl_int dummy_errcode;
auto context = pobj(d_context);
if (!errcode_ret)
errcode_ret = &dummy_errcode;
if (!context->isA(Coal::Object::T_Context))
{
*errcode_ret = CL_INVALID_CONTEXT;
return 0;
}
*errcode_ret = CL_SUCCESS;
Coal::Sampler *sampler = new Coal::Sampler(context,
normalized_coords,
addressing_mode,
filter_mode,
errcode_ret);
if (*errcode_ret != CL_SUCCESS)
{
delete sampler;
return 0;
}
return desc(sampler);
}
int Container::isEqual( const Object& testContainer ) const
{
PRECONDITION( isA() == testContainer.isA() );
int res = 1;
ContainerIterator& thisIterator = initIterator();
ContainerIterator& testContainerIterator =
((Container &)(testContainer)).initIterator();
while( thisIterator != 0 && testContainerIterator != 0 )
{
if( thisIterator++ != testContainerIterator++ )
{
res = 0;
break;
}
}
if( thisIterator != 0 || testContainerIterator != 0 )
res = 0;
delete &testContainerIterator;
delete &thisIterator;
return res;
}
static QueryOperator *
translateInsert(Insert *insert)
{
List *attr = getAttributeNames(insert->tableName);
List *dts = getAttributeDataTypes(insert->tableName);
QueryOperator *insertQuery;
TableAccessOperator *to;
to = createTableAccessOp(insert->tableName, NULL, NULL, NIL, deepCopyStringList(attr), dts);
SET_BOOL_STRING_PROP(to,PROP_TABLE_IS_UPDATED);
if (isA(insert->query, List))
{
ConstRelOperator *co;
co = createConstRelOp((List *) insert->query,NIL, deepCopyStringList(attr), dts);
insertQuery= (QueryOperator *) co;
}
else
insertQuery = translateQuery((Node *) insert->query);
SetOperator *seto;
seto = createSetOperator(SETOP_UNION, NIL, NIL, deepCopyStringList(attr));
addChildOperator((QueryOperator *) seto, (QueryOperator *) to);
addChildOperator((QueryOperator *) seto, insertQuery);
INFO_LOG("translated insert:\n%s", operatorToOverviewString((Node *) seto));
DEBUG_LOG("translated insert:\n%s", nodeToString((Node *) seto));
return (QueryOperator *) seto;
}
void emitBindG(IRGS& env) {
auto const name = topC(env, BCSPOffset{1});
if (!name->isA(TStr)) PUNT(BindG-NameNotStr);
auto const box = popV(env);
auto const ptr = gen(env, LdGblAddrDef, name);
destroyName(env, name);
bindMem(env, ptr, box);
}
void emitSetG(IRGS& env) {
auto const name = topC(env, BCSPOffset{1});
if (!name->isA(TStr)) PUNT(SetG-NameNotStr);
auto const value = popC(env, DataTypeCountness);
auto const unboxed = gen(env, UnboxPtr, gen(env, LdGblAddrDef, name));
destroyName(env, name);
bindMem(env, unboxed, value);
}
void
shMonster::makePet ()
{
if (isA (kMonClerkbot)) {
/* nice try */
return;
}
mTame = 1;
mDisposition = kHelpful;
mTactic = kReady;
mStrategy = kPet;
//mGlyph.mSym |= A_REVERSE;
if (isA (kMonCylonCenturion)) { /* The iconic phrase must be there. */
I->p ("\"By your command.\"");
}
Hero.mPets.add (this);
}
/**
* Trace back to the guard that provided the type of val, if
* any. Constrain it so its type will not be relaxed beyond the given
* DataTypeCategory. Always returns val, for convenience.
*/
SSATmp* TraceBuilder::constrainValue(SSATmp* const val, DataTypeCategory cat) {
if (!val) {
FTRACE(1, "constrainValue(nullptr, {}), bailing\n", cat);
return nullptr;
}
FTRACE(1, "constrainValue({}, {})\n", *val->inst(), cat);
// If cat is DataTypeGeneric, there's nothing to do.
if (cat == DataTypeGeneric) return val;
auto inst = val->inst();
if (inst->op() == LdLoc || inst->op() == LdLocAddr) {
// We've hit a LdLoc(Addr). If the source of the value is non-null and not
// a FramePtr, it's a real value that was killed by a Call. The value won't
// be live but it's ok to use it to track down the guard.
auto source = inst->extra<LdLocData>()->valSrc;
if (!source) {
// val was newly created in this trace. Nothing to constrain.
FTRACE(2, " - valSrc is null, bailing\n");
return val;
}
// If valSrc is a FramePtr, it represents the frame the value was
// originally loaded from. Look for the guard for this local.
if (source->isA(Type::FramePtr)) {
constrainLocal(inst->extra<LocalId>()->locId, source, cat,
"constrainValue");
return val;
}
// Otherwise, keep chasing down the source of val.
constrainValue(source, cat);
} else if (inst->op() == LdStack) {
constrainStack(inst->src(0), inst->extra<StackOffset>()->offset, cat);
} else if (inst->op() == CheckType) {
// Constrain this CheckType and keep going on its source value, in case
// there are more guards to constrain.
constrainGuard(inst, cat);
constrainValue(inst->src(0), cat);
} else if (inst->op() == StRef || inst->op() == StRefNT) {
// TODO(t2598894): This can be tightened up. As a conservative
// approximation, pass the constraint through to the source of the value.
constrainValue(inst->src(1), cat);
} else if (inst->isPassthrough()) {
constrainValue(inst->getPassthroughValue(), cat);
} else {
// Any instructions not special cased above produce a new value, so
// there's no guard for us to constrain.
FTRACE(2, " - value is new in this trace, bailing\n");
}
return val;
}
void emitVGetG(IRGS& env) {
auto const name = topC(env);
if (!name->isA(TStr)) PUNT(VGetG-NonStrName);
auto const ptr = gen(env, LdGblAddrDef, name);
destroyName(env, name);
pushIncRef(
env,
gen(env, LdMem, TBoxedInitCell, gen(env, BoxPtr, ptr))
);
}
// Command Queue APIs
cl_command_queue
clCreateCommandQueue(cl_context d_context,
cl_device_id d_device,
cl_command_queue_properties properties,
cl_int * errcode_ret)
{
cl_int default_errcode_ret;
auto device = pobj(d_device);
auto context = pobj(d_context);
// No errcode_ret ?
if (!errcode_ret)
errcode_ret = &default_errcode_ret;
if (!device->isA(Coal::Object::T_Device))
{
*errcode_ret = CL_INVALID_DEVICE;
return 0;
}
if (!context->isA(Coal::Object::T_Context))
{
*errcode_ret = CL_INVALID_CONTEXT;
return 0;
}
*errcode_ret = CL_SUCCESS;
Coal::CommandQueue *queue = new Coal::CommandQueue(
context,
device,
properties,
errcode_ret);
if (*errcode_ret != CL_SUCCESS)
{
// Initialization failed, destroy context
delete queue;
return 0;
}
return desc(queue);
}
cl_int
clRetainKernel(cl_kernel d_kernel)
{
auto kernel = pobj(d_kernel);
if (!kernel->isA(Coal::Object::T_Kernel))
return CL_INVALID_KERNEL;
kernel->reference();
return CL_SUCCESS;
}
void emitCGetG(IRGS& env) {
auto const exit = makeExitSlow(env);
auto const name = topC(env);
if (!name->isA(TStr)) PUNT(CGetG-NonStrName);
auto const ptr = gen(env, LdGblAddr, exit, name);
destroyName(env, name);
pushIncRef(
env,
gen(env, LdMem, TCell, gen(env, UnboxPtr, ptr))
);
}
cl_int
clRetainDevice(cl_device_id d_device)
{
auto device = pobj(d_device);
if (!device->isA(Coal::Object::T_Device))
return CL_INVALID_DEVICE;
device->reference();
return CL_SUCCESS;
}
cl_int
clRetainSampler(cl_sampler d_sampler)
{
auto sampler = pobj(d_sampler);
if (!sampler->isA(Coal::Object::T_Sampler))
return CL_INVALID_SAMPLER;
sampler->reference();
return CL_SUCCESS;
}
cl_int
clSetKernelArg(cl_kernel d_kernel,
cl_uint arg_indx,
size_t arg_size,
const void * arg_value)
{
auto kernel = pobj(d_kernel);
if (!kernel->isA(Coal::Object::T_Kernel))
return CL_INVALID_KERNEL;
return kernel->setArg(arg_indx, arg_size, arg_value);
}
/* function definitions */
Node *
provRewriteQBModel (Node *qbModel)
{
if (isA(qbModel, List))
return (Node *) provRewriteQueryList((List *) qbModel);
else if (IS_OP(qbModel))
return (Node *) provRewriteQuery((QueryOperator *) qbModel);
FATAL_LOG("cannot rewrite node <%s>", nodeToString(qbModel));
return NULL;
}
static void *Iterable_constructor (void *_self, va_list *app)
{
Class_constructor_m ctor = method (super (Iterable ()), "__constructor__");
struct Iterable *self = ctor (_self, app);
if (isA (self, Iterable ()))
{
throw (AbstractError, "Iterable: cannot instantiate abstract class");
}
return self;
}
cl_int
clRetainMemObject(cl_mem d_memobj)
{
auto memobj = pobj(d_memobj);
if (!memobj->isA(Coal::Object::T_MemObject))
return CL_INVALID_MEM_OBJECT;
memobj->reference();
return CL_SUCCESS;
}
cl_int
clRetainCommandQueue(cl_command_queue d_command_queue)
{
auto command_queue = pobj(d_command_queue);
if (!command_queue->isA(Coal::Object::T_CommandQueue))
return CL_INVALID_COMMAND_QUEUE;
command_queue->reference();
return CL_SUCCESS;
}
/*----------------------------------------------------------------------*/
static void showInstance(int ins)
{
char str[80];
if (ins > header->instanceMax) {
sprintf(str, "Instance code %d is out of range", ins);
output(str);
return;
}
output("The");
say(ins);
sprintf(str, "[%d]", ins);
output(str);
if (instances[ins].parent) {
sprintf(str, "Isa %s[%d]", idOfClass(instances[ins].parent), instances[ins].parent);
output(str);
}
if (!isA(ins, header->locationClassId) || (isA(ins, header->locationClassId) && admin[ins].location != 0)) {
sprintf(str, "$iLocation: ");
output(str);
showInstanceLocation(ins, " ");
}
output("$iAttributes:");
showAttributes(admin[ins].attributes);
if (instances[ins].container)
showContents(ins);
if (isA(ins, header->actorClassId)) {
if (admin[ins].script == 0)
output("$iIs idle");
else {
sprintf(str, "$iExecuting script: %d, Step: %d", admin[ins].script, admin[ins].step);
output(str);
}
}
}
void * reduce_phase2(const void * _exp)
{
if(isA(_exp, Integer()))
return domainCast(_exp, Real());
else if(isA(_exp, Real()) || isA(_exp, Var()))
return copy(_exp);
else if(isA(_exp, Sum()) || isA(_exp, Product()))
{
void * s = copy(_exp);
size_t i;
for(i = 0; i < size(s); ++i)
{
delete(argv(s, i));
setArgv(s, i, reduce_phase2(argv(_exp, i)));
}
return s;
}
else if(isA(_exp, Pow()))
{
void * p = copy(_exp);
delete(base(p));
delete(power(p));
setBase(p, reduce_phase2(base(_exp)));
setPower(p, reduce_phase2(power(_exp)));
return p;
}
else if(isOf(_exp, Apply_1()))
{
void * f = copy(_exp);
delete(arg(f));
setArg(f, reduce_phase2(arg(_exp)));
return f;
}
assert(0);
}
cl_int
clReleaseMemObject(cl_mem d_memobj)
{
auto memobj = pobj(d_memobj);
if (!memobj->isA(Coal::Object::T_MemObject))
return CL_INVALID_MEM_OBJECT;
if (memobj->dereference())
delete memobj;
return CL_SUCCESS;
}
cl_int
clSetCommandQueueProperty(cl_command_queue d_command_queue,
cl_command_queue_properties properties,
cl_bool enable,
cl_command_queue_properties * old_properties)
{
auto command_queue = pobj(d_command_queue);
if (!command_queue->isA(Coal::Object::T_CommandQueue))
return CL_INVALID_COMMAND_QUEUE;
return command_queue->setProperty(properties, enable, old_properties);
}
