TypePtr variantType(VariantPtr variant, const vector<ObjectPtr> ¶ms) {
int h = pointerHash(variant.ptr());
for (unsigned i = 0; i < params.size(); ++i)
h += objectHash(params[i]);
h &= variantTypes.size() - 1;
vector<VariantTypePtr> &bucket = variantTypes[h];
for (unsigned i = 0; i < bucket.size(); ++i) {
VariantType *t = bucket[i].ptr();
if ((t->variant == variant) && objectVectorEquals(t->params, params))
return t;
}
VariantTypePtr t = new VariantType(variant);
for (unsigned i = 0; i < params.size(); ++i)
t->params.push_back(params[i]);
bucket.push_back(t);
return t.ptr();
}
TypePtr recordType(RecordPtr record, const vector<ObjectPtr> ¶ms) {
int h = pointerHash(record.ptr());
vector<ObjectPtr>::const_iterator pi, pend;
for (pi = params.begin(), pend = params.end(); pi != pend; ++pi)
h += objectHash(*pi);
h &= recordTypes.size() - 1;
vector<RecordTypePtr>::iterator i, end;
for (i = recordTypes[h].begin(), end = recordTypes[h].end();
i != end; ++i) {
RecordType *t = i->ptr();
if ((t->record == record) && objectVectorEquals(t->params, params))
return t;
}
RecordTypePtr t = new RecordType(record);
for (pi = params.begin(), pend = params.end(); pi != pend; ++pi)
t->params.push_back(*pi);
recordTypes[h].push_back(t);
initializeRecordFields(t);
return t.ptr();
}
InvokeSetPtr lookupInvokeSet(ObjectPtr callable,
const vector<TypePtr> &argsKey)
{
if (!invokeTablesInitialized)
initInvokeTables();
int h = objectHash(callable) + objectVectorHash(argsKey);
h &= (invokeTable.size() - 1);
vector<InvokeSetPtr> &bucket = invokeTable[h];
for (unsigned i = 0; i < bucket.size(); ++i) {
InvokeSetPtr invokeSet = bucket[i];
if (objectEquals(invokeSet->callable, callable) &&
objectVectorEquals(invokeSet->argsKey, argsKey))
{
return invokeSet;
}
}
OverloadPtr interface = callableInterface(callable);
const vector<OverloadPtr> &overloads = callableOverloads(callable);
InvokeSetPtr invokeSet = new InvokeSet(callable, argsKey, interface, overloads);
bucket.push_back(invokeSet);
return invokeSet;
}
InvokeSet* lookupInvokeSet(ObjectPtr callable,
llvm::ArrayRef<TypePtr> argsKey)
{
if (!invokeTablesInitialized)
initInvokeTables();
int h = objectHash(callable) + objectVectorHash(argsKey);
h &= (invokeTable.size() - 1);
llvm::SmallVector<InvokeSet*, 2> &bucket = invokeTable[h];
for (unsigned i = 0; i < bucket.size(); ++i) {
InvokeSet* invokeSet = bucket[i];
if (objectEquals(invokeSet->callable, callable) &&
objectVectorEquals(invokeSet->argsKey, argsKey))
{
return invokeSet;
}
}
OverloadPtr interface = callableInterface(callable);
llvm::ArrayRef<OverloadPtr> overloads = callableOverloads(callable);
InvokeSet* invokeSet = new InvokeSet(callable, argsKey, interface, overloads);
invokeSet->shouldLog = shouldLogCallable(callable);
bucket.push_back(invokeSet);
return invokeSet;
}
