struct Entry {

uint64_t id;

vector<string> pass;

vector<string> before;

vector<string> after;

};

vector<Entry> entires;

struct Node {

uint64_t id;

vector<uint64_t> before;

};

vector<Node> build_unsorted () {

map<uint64_t, Node> nodes;

map<string, set<uint64_t>> tags;

for ( auto & e : entires ) {

Node & n = nodes[e.id];

n.id = e.id;

for ( auto & p : e.pass ) {

tags[p].insert(e.id);

}

}

for ( auto & e : entires ) {

Node & n = nodes[e.id];

for ( auto & b : e.before ) {

for ( auto & t : tags[b] ) {

n.before.push_back(t);

}

}

for ( auto & a : e.after ) {

for ( auto & t : tags[a] ) {

nodes[t].before.push_back(e.id);

}

}

}

vector<Node> unsorted;

for ( auto & n : nodes ) {

unsorted.emplace_back(n.second);

}

return unsorted;

}

vector<uint64_t> sort () {

auto unsorted = build_unsorted();

vector<uint64_t> result;

auto lnodes = unsorted.size();

if ( lnodes != 0 ) {

vector<Node> sorted;

sorted.reserve(lnodes);

while ( unsorted.size() ) {

auto node = das::move(unsorted[0]);

unsorted.erase(unsorted.begin());

if ( node.before.size()==0 ) {

for ( auto & other : unsorted ) {

for ( int i=int(other.before.size())-1; i>=0; --i ) {

if ( other.before[i] == node.id ) {

other.before.erase(other.before.begin()+i);

}

}

}

sorted.emplace_back(node);

} else {

unsorted.emplace_back(node);

}

}

DAS_ASSERTF(sorted.size()==lnodes,"cyclic dependency in [init] nodes");

result.reserve(lnodes);

for ( auto & n : sorted ) {

result.push_back(n.id);

}

}

return result;

}

void addNode ( uint64_t mnh, AnnotationArgumentList & args ) {

Entry e;

e.id = mnh;

for ( auto & arg : args ) {

if ( arg.name=="tag" && arg.type==Type::tString ) {

e.pass.push_back(arg.sValue);

} else if ( arg.name=="before" && arg.type==Type::tString ) {

e.before.push_back(arg.sValue);

} else if ( arg.name=="after" && arg.type==Type::tString ) {

e.after.push_back(arg.sValue);

}

}

entires.push_back(e);

}

useStackRef = ref;

useCMRES = cmres;

doesNotNeedSp = true;

doesNotNeedInit = true;

stackTop = sp;

extraOffset = off;

ExprMakeLocal::setRefSp(ref, cmres, sp, off);

int stride = makeType->getStride();

// we go through all fields, and if its [[ ]] field

// we tell it to piggy-back on our current sp, with appropriate offset

int index = 0;

for ( const auto & decl : variants ) {

auto fieldVariant = makeType->findArgumentIndex(decl->name);

DAS_ASSERT(fieldVariant!=-1 && "should have failed in type infer otherwise");

auto fieldType = makeType->argTypes[fieldVariant];

if ( decl->value->rtti_isMakeLocal() ) {

auto fieldOffset = makeType->getVariantFieldOffset(fieldVariant);

uint32_t offset = extraOffset + index*stride + fieldOffset;

auto mkl = static_pointer_cast<ExprMakeLocal>(decl->value);

mkl->setRefSp(ref, cmres, sp, offset);

} else if ( decl->value->rtti_isCall() ) {

auto cll = static_pointer_cast<ExprCall>(decl->value);

if ( cll->allowCmresSkip() ) {

cll->doesNotNeedSp = true;

}

} else if ( decl->value->rtti_isInvoke() ) {

auto cll = static_pointer_cast<ExprInvoke>(decl->value);

if ( cll->allowCmresSkip() ) {

cll->doesNotNeedSp = true;

}

}

index++;

}

vector<SimNode *> simlist;

int index = 0;

int stride = makeType->getStride();

// init with 0 it its 'default' initialization

if ( stride && variants.empty() ) {

int bytes = stride;

SimNode * init0;

if ( useCMRES ) {

if ( bytes <= 32 ) {

init0 = context.code->makeNodeUnrollNZ<SimNode_InitLocalCMResN>(bytes, at,extraOffset);

} else {

init0 = context.code->makeNode<SimNode_InitLocalCMRes>(at,extraOffset,bytes);

}

} else if ( useStackRef ) {

init0 = context.code->makeNode<SimNode_InitLocalRef>(at,stackTop,extraOffset,bytes);

} else {

init0 = context.code->makeNode<SimNode_InitLocal>(at,stackTop + extraOffset,bytes);

}

simlist.push_back(init0);

}

// now fields

for ( const auto & decl : variants ) {

auto fieldVariant = makeType->findArgumentIndex(decl->name);

DAS_ASSERT(fieldVariant!=-1 && "should have failed in type infer otherwise");

// lets set variant index

uint32_t voffset = extraOffset + index*stride;

auto vconst = make_smart<ExprConstInt>(at, int32_t(fieldVariant));

vconst->type = make_smart<TypeDecl>(Type::tInt);

SimNode * svi;

if ( useCMRES ) {

svi = makeLocalCMResCopy(at,context,voffset,vconst);

} else if (useStackRef) {

svi = makeLocalRefCopy(at,context,stackTop,voffset,vconst);

} else {

svi = makeLocalCopy(at,context,stackTop+voffset,vconst);

}

simlist.push_back(svi);

// field itself

auto fieldOffset = makeType->getVariantFieldOffset(fieldVariant);

uint32_t offset = voffset + fieldOffset;

SimNode * cpy;

if ( decl->value->rtti_isMakeLocal() ) {

// so what happens here, is we ask it for the generated commands and append it to this list only

auto mkl = static_pointer_cast<ExprMakeLocal>(decl->value);

auto lsim = mkl->simulateLocal(context);

simlist.insert(simlist.end(), lsim.begin(), lsim.end());

continue;

} else if ( useCMRES ) {

if ( decl->moveSemantics ){

cpy = makeLocalCMResMove(at,context,offset,decl->value);

} else {

cpy = makeLocalCMResCopy(at,context,offset,decl->value);

}

} else if ( useStackRef ) {

if ( decl->moveSemantics ){

cpy = makeLocalRefMove(at,context,stackTop,offset,decl->value);

} else {

cpy = makeLocalRefCopy(at,context,stackTop,offset,decl->value);

}

} else {

if ( decl->moveSemantics ){

cpy = makeLocalMove(at,context,stackTop+offset,decl->value);

} else {

cpy = makeLocalCopy(at,context,stackTop+offset,decl->value);

}

}

if ( !cpy ) {

context.thisProgram->error("internal compilation error, can't generate structure initialization", "", "", at);

}

simlist.push_back(cpy);

index++;

}

return simlist;

ExprMakeLocal::setRefSp(ref, cmres, sp, off);

// if it's a handle type, we can't reuse the make-local chain

if ( makeType->baseType == Type::tHandle ) return;

// we go through all fields, and if its [[ ]] field

// we tell it to piggy-back on our current sp, with appropriate offset

int total = int(structs.size());

int stride = makeType->getStride();

for ( int index=0; index != total; ++index ) {

auto & fields = structs[index];

for ( const auto & decl : *fields ) {

auto field = makeType->structType->findField(decl->name);

DAS_ASSERT(field && "should have failed in type infer otherwise");

if ( decl->value->rtti_isMakeLocal() ) {

uint32_t offset = extraOffset + index*stride + field->offset;

auto mkl = static_pointer_cast<ExprMakeLocal>(decl->value);

mkl->setRefSp(ref, cmres, sp, offset);

} else if ( decl->value->rtti_isCall() ) {

auto cll = static_pointer_cast<ExprCall>(decl->value);

if ( cll->allowCmresSkip() ) {

cll->doesNotNeedSp = true;

}

} else if ( decl->value->rtti_isInvoke() ) {

auto cll = static_pointer_cast<ExprInvoke>(decl->value);

if ( cll->allowCmresSkip() ) {

cll->doesNotNeedSp = true;

}

}

}

}

vector<SimNode *> simlist;

// init with 0

int total = int(structs.size());

int stride = makeType->getStride();

if ( !doesNotNeedInit && !initAllFields && stride ) {

int bytes = das::max(total,1) * stride;

SimNode * init0;

if ( useCMRES ) {

if ( bytes <= 32 ) {

init0 = context.code->makeNodeUnrollNZ<SimNode_InitLocalCMResN>(bytes, at,extraOffset);

} else {

init0 = context.code->makeNode<SimNode_InitLocalCMRes>(at,extraOffset,bytes);

}

} else if ( useStackRef ) {

init0 = context.code->makeNode<SimNode_InitLocalRef>(at,stackTop,extraOffset,bytes);

} else {

init0 = context.code->makeNode<SimNode_InitLocal>(at,stackTop + extraOffset,bytes);

}

simlist.push_back(init0);

}

if ( makeType->baseType == Type::tStructure ) {

for ( int index=0; index != total; ++index ) {

auto & fields = structs[index];

for ( const auto & decl : *fields ) {

auto field = makeType->structType->findField(decl->name);

DAS_ASSERT(field && "should have failed in type infer otherwise");

uint32_t offset = extraOffset + index*stride + field->offset;

SimNode * cpy;

if ( decl->value->rtti_isMakeLocal() ) {

// so what happens here, is we ask it for the generated commands and append it to this list only

auto mkl = static_pointer_cast<ExprMakeLocal>(decl->value);

auto lsim = mkl->simulateLocal(context);

simlist.insert(simlist.end(), lsim.begin(), lsim.end());

continue;

} else if ( useCMRES ) {

if ( decl->moveSemantics ){

cpy = makeLocalCMResMove(at,context,offset,decl->value);

} else {

cpy = makeLocalCMResCopy(at,context,offset,decl->value);

}

} else if ( useStackRef ) {

if ( decl->moveSemantics ){

cpy = makeLocalRefMove(at,context,stackTop,offset,decl->value);

} else {

cpy = makeLocalRefCopy(at,context,stackTop,offset,decl->value);

}

} else {

if ( decl->moveSemantics ){

cpy = makeLocalMove(at,context,stackTop+offset,decl->value);

} else {

cpy = makeLocalCopy(at,context,stackTop+offset,decl->value);

}

}

if ( !cpy ) {

context.thisProgram->error("internal compilation error, can't generate structure initialization", "", "", at);

}

simlist.push_back(cpy);

}

}

} else {

auto ann = makeType->annotation;

// making fake variable, which points to out field

string fakeName = "__makelocal";

auto fakeVariable = make_smart<Variable>();

fakeVariable->name = fakeName;

fakeVariable->type = make_smart<TypeDecl>(Type::tHandle);

fakeVariable->type->annotation = ann;

fakeVariable->at = at;

if ( useCMRES ) {

fakeVariable->aliasCMRES = true;

} else if ( useStackRef ) {

fakeVariable->stackTop = stackTop;

fakeVariable->extraLocalOffset = extraOffset;

fakeVariable->type->ref = true;

if ( total != 1 ) {

fakeVariable->type->dim.push_back(total);

}

}

fakeVariable->generated = true;

// make fake ExprVar which is that field

auto fakeVar = make_smart<ExprVar>(at, fakeName);

fakeVar->type = fakeVariable->type;

fakeVar->variable = fakeVariable;

fakeVar->local = true;

// make fake expression

ExpressionPtr fakeExpr = fakeVar;

smart_ptr<ExprConstInt> indexExpr;

if ( useStackRef && total > 1 ) {

// if its stackRef with multiple indices, its actually var[total], and lookup is var[index]

indexExpr = make_smart<ExprConstInt>(at, 0);

indexExpr->type = make_smart<TypeDecl>(Type::tInt);

fakeExpr = make_smart<ExprAt>(at, fakeExpr, indexExpr);

fakeExpr->type = make_smart<TypeDecl>(Type::tHandle);

fakeExpr->type->annotation = ann;

fakeExpr->type->ref = true;

}

for ( int index=0; index != total; ++index ) {

auto & fields = structs[index];

// adjust var for index

if ( useCMRES ) {

fakeVariable->stackTop = extraOffset + index*stride;

} else if ( useStackRef ) {

if ( total > 1 ) {

indexExpr->value = cast<int32_t>::from(index);

}

} else {

fakeVariable->stackTop = stackTop + extraOffset + index*stride;

}

// now, setup fields

for ( const auto & decl : *fields ) {

auto fieldType = ann->makeFieldType(decl->name, false);

DAS_ASSERT(fieldType && "how did this infer?");

uint32_t fieldSize = fieldType->getSizeOf();

SimNode * cpy = nullptr;

uint32_t fieldOffset = ann->getFieldOffset(decl->name);

SimNode * simV = fakeExpr->simulate(context);

auto left = context.code->makeNode<SimNode_FieldDeref>(at,simV,fieldOffset);

auto right = decl->value->simulate(context);

if ( !decl->value->type->isRef() ) {

if ( decl->value->type->isHandle() ) {

auto rightType = decl->value->type;

cpy = rightType->annotation->simulateCopy(context, at, left,

(!rightType->isRefType() && rightType->ref) ? rightType->annotation->simulateRef2Value(context, at, right) : right);

if ( !cpy ) {

context.thisProgram->error("integration error, simulateCopy returned null", "", "",

at, CompilationError::missing_node );

}

} else {

cpy = context.code->makeValueNode<SimNode_Set>(decl->value->type->baseType, decl->at, left, right);

}

} else if ( decl->moveSemantics ) {

cpy = context.code->makeNode<SimNode_MoveRefValue>(decl->at, left, right, fieldSize);

} else {

cpy = context.code->makeNode<SimNode_CopyRefValue>(decl->at, left, right, fieldSize);

}

simlist.push_back(cpy);

}

}

}

if ( block ) {

/*

// making fake variable, which points to entire structure

string fakeName = "__makelocal";

auto fakeVariable = make_smart<Variable>();

fakeVariable->name = fakeName;

fakeVariable->type = make_smart<TypeDecl>(*type);

if ( useCMRES ) {

fakeVariable->aliasCMRES = true;

} else if ( useStackRef ) {

fakeVariable->stackTop = stackTop + extraOffset;

fakeVariable->type->ref = true;

} else {

fakeVariable->stackTop = stackTop + extraOffset;

}

fakeVariable->generated = true;

// make fake ExprVar which is that field

auto fakeVar = make_smart<ExprVar>(at, fakeName);

fakeVar->type = fakeVariable->type;

fakeVar->variable = fakeVariable;

fakeVar->local = true;

// make fake invoke expression

auto fakeInvoke = make_smart<ExprInvoke>(at,"invoke");

fakeInvoke->arguments.push_back(block);

fakeInvoke->arguments.push_back(fakeVar);

// simulate it

auto simI = fakeInvoke->simulate(context);

simlist.push_back(simI);

}

return simlist;

ExprMakeLocal::setRefSp(ref, cmres, sp, off);

int total = int(values.size());

uint32_t stride = recordType->getSizeOf();

for ( int index=0; index != total; ++index ) {

auto & val = values[index];

if ( val->rtti_isMakeLocal() ) {

uint32_t offset = extraOffset + index*stride;

auto mkl = static_pointer_cast<ExprMakeLocal>(val);

mkl->setRefSp(ref, cmres, sp, offset);

} else if ( val->rtti_isCall() ) {

auto cll = static_pointer_cast<ExprCall>(val);

if ( cll->allowCmresSkip() ) {

cll->doesNotNeedSp = true;

}

} else if ( val->rtti_isInvoke() ) {

auto cll = static_pointer_cast<ExprInvoke>(val);

if ( cll->allowCmresSkip() ) {

cll->doesNotNeedSp = true;

}

}

}

vector<SimNode *> simlist;

// init with 0

int total = int(values.size());

uint32_t stride = recordType->getSizeOf();

if ( !doesNotNeedInit && !initAllFields ) {

int bytes = total * stride;

SimNode * init0;

if ( useCMRES ) {

if ( bytes <= 32 ) {

init0 = context.code->makeNodeUnrollNZ<SimNode_InitLocalCMResN>(bytes, at,extraOffset);

} else {

init0 = context.code->makeNode<SimNode_InitLocalCMRes>(at,extraOffset,bytes);

}

} else if ( useStackRef ) {

init0 = context.code->makeNode<SimNode_InitLocalRef>(at,stackTop,extraOffset,stride * total);

} else {

init0 = context.code->makeNode<SimNode_InitLocal>(at,stackTop + extraOffset,stride * total);

}

simlist.push_back(init0);

}

for ( int index=0; index != total; ++index ) {

auto & val = values[index];

uint32_t offset = extraOffset + index*stride;

SimNode * cpy;

if ( val->rtti_isMakeLocal() ) {

// so what happens here, is we ask it for the generated commands and append it to this list only

auto mkl = static_pointer_cast<ExprMakeLocal>(val);

auto lsim = mkl->simulateLocal(context);

simlist.insert(simlist.end(), lsim.begin(), lsim.end());

continue;

} else if ( useCMRES ) {

if (val->type->canCopy()) {

cpy = makeLocalCMResCopy(at, context, offset, val);

} else {

cpy = makeLocalCMResMove(at, context, offset, val);

}

} else if ( useStackRef ) {

if (val->type->canCopy()) {

cpy = makeLocalRefCopy(at, context, stackTop, offset, val);

} else {

cpy = makeLocalRefMove(at, context, stackTop, offset, val);

}

} else {

if (val->type->canCopy()) {

cpy = makeLocalCopy(at, context, stackTop + offset, val);

} else {

cpy = makeLocalMove(at, context, stackTop + offset, val);

}

}

if ( !cpy ) {

context.thisProgram->error("internal compilation error, can't generate array initialization", "", "", at);

}

simlist.push_back(cpy);

}

return simlist;

ExprMakeLocal::setRefSp(ref, cmres, sp, off);

int total = int(values.size());

for ( int index=0; index != total; ++index ) {

auto & val = values[index];

if ( val->rtti_isMakeLocal() ) {

uint32_t offset = extraOffset + makeType->getTupleFieldOffset(index);

auto mkl = static_pointer_cast<ExprMakeLocal>(val);

mkl->setRefSp(ref, cmres, sp, offset);

} else if ( val->rtti_isCall() ) {

auto cll = static_pointer_cast<ExprCall>(val);

if ( cll->allowCmresSkip() ) {

cll->doesNotNeedSp = true;

}

} else if ( val->rtti_isInvoke() ) {

auto cll = static_pointer_cast<ExprInvoke>(val);

if ( cll->allowCmresSkip() ) {

cll->doesNotNeedSp = true;

}

}

}

vector<SimNode *> simlist;

// init with 0

int total = int(values.size());

if ( !doesNotNeedInit && !initAllFields ) {

uint32_t sizeOf = makeType->getSizeOf();

SimNode * init0;

if ( useCMRES ) {

if ( sizeOf <= 32 ) {

init0 = context.code->makeNodeUnrollNZ<SimNode_InitLocalCMResN>(sizeOf, at,extraOffset);

} else {

init0 = context.code->makeNode<SimNode_InitLocalCMRes>(at,extraOffset,sizeOf);

}

} else if ( useStackRef ) {

init0 = context.code->makeNode<SimNode_InitLocalRef>(at,stackTop,extraOffset,sizeOf);

} else {

init0 = context.code->makeNode<SimNode_InitLocal>(at,stackTop + extraOffset,sizeOf);

}

simlist.push_back(init0);

}

for ( int index=0; index != total; ++index ) {

auto & val = values[index];

uint32_t offset = extraOffset + makeType->getTupleFieldOffset(index);

SimNode * cpy;

if ( val->rtti_isMakeLocal() ) {

// so what happens here, is we ask it for the generated commands and append it to this list only