bool PolymorphicMacroCache::getCompleteIn(MacroDef & macrodef, AnalysisVisitor & visitor, const std::vector<TIType> & in, std::vector<TIType> & completeIn)
{
for (const auto & ty : in)
{
if (ty.type == TIType::UNKNOWN)
{
return false;
}
}
const tools::SymbolOrdSet & globals = macrodef.getGlobals();
completeIn.reserve(in.size() + globals.size());
for (const auto & ty : in)
{
completeIn.emplace_back(ty);
}
const std::vector<symbol::Symbol> & declaredIn = macrodef.getIn();
const unsigned int size = declaredIn.size();
DataManager & dm = visitor.getDM();
if (in.size() < size)
{
// we have less rhs than declared rhs:
// function foo(x,y,z)...endfunction
// called with foo(x) so y and z are globals
for (unsigned int i = in.size(); i < size; ++i)
{
completeIn.emplace_back(dm.getType(declaredIn[i]));
}
}
for (const auto & sym : globals)
{
TIType ty = dm.getType(sym, /* global */ true);
completeIn.emplace_back(ty);
if (ty.type == TIType::UNKNOWN)
{
return false;
}
}
return true;
}
bool MatrixAnalyzer::analyze(AnalysisVisitor & visitor, const unsigned int lhs, ast::CallExp & e)
{
if (lhs > 1)
{
return false;
}
const ast::exps_t args = e.getArgs();
const unsigned int size = args.size();
if (size != 2 && size != 3)
{
return false;
}
if (size == 2)
{
return analyze2Args(visitor, args, e);
}
ast::Exp * first = args[0];
ast::Exp * second = args[1];
ast::Exp * third = args[2];
first->accept(visitor);
Result R1 = visitor.getResult();
if (!R1.getType().ismatrix())
{
return false;
}
second->accept(visitor);
Result R2 = visitor.getResult();
third->accept(visitor);
Result & R3 = visitor.getResult();
double val;
SymbolicDimension rows;
SymbolicDimension cols;
if (R2.getConstant().getDblValue(val))
{
const int nrows = tools::cast<int>(val);
if (nrows <= 0)
{
return false;
}
else
{
rows = SymbolicDimension(visitor.getGVN(), nrows);
}
}
else if (GVN::Value * gvnValue = R2.getConstant().getGVNValue())
{
if (gvnValue->poly->isConstant() && gvnValue->poly->constant <= 0)
{
return false;
}
rows.setValue(gvnValue);
rows.setGVN(&visitor.getGVN());
}
else
{
return false;
}
if (R3.getConstant().getDblValue(val))
{
const int ncols = tools::cast<int>(val);
if (ncols <= 0)
{
return false;
}
else
{
cols = SymbolicDimension(visitor.getGVN(), ncols);
}
}
else if (GVN::Value * gvnValue = R3.getConstant().getGVNValue())
{
if (gvnValue->poly->isConstant() && gvnValue->poly->constant <= 0)
{
return false;
}
cols.setValue(gvnValue);
cols.setGVN(&visitor.getGVN());
}
else
{
return false;
}
const TIType & type = R1.getType();
SymbolicDimension prod1 = type.rows * type.cols;
SymbolicDimension prod2 = rows * cols;
bool res = visitor.getCM().check(ConstraintManager::EQUAL, prod1.getValue(), prod2.getValue());
if (res)
{
res = visitor.getCM().check(ConstraintManager::POSITIVE, rows.getValue());
if (!res)
{
return false;
}
}
else
{
return false;
}
TIType resT(visitor.getGVN(), R1.getType().type, rows, cols);
int tempId;
if (R1.getTempId() != -1)
{
tempId = R1.getTempId();
}
else
{
tempId = visitor.getDM().getTmpId(resT, false);
}
Result & _res = e.getDecorator().setResult(Result(resT, tempId));
visitor.setResult(_res);
return true;
}
bool MatrixAnalyzer::analyze2Args(AnalysisVisitor & visitor, const ast::exps_t & args, ast::CallExp & e)
{
ast::Exp * first = args[0];
ast::Exp * second = args[1];
first->accept(visitor);
Result R1 = visitor.getResult();
if (!R1.getType().ismatrix())
{
return false;
}
SymbolicDimension rows;
SymbolicDimension cols;
bool hasRC = false;
if (second->isCallExp())
{
ast::CallExp & ce = static_cast<ast::CallExp &>(*second);
if (ce.getName().isSimpleVar())
{
ast::SimpleVar & var = static_cast<ast::SimpleVar &>(ce.getName());
const symbol::Symbol & sym = var.getSymbol();
const std::wstring & name = sym.getName();
if (name == L"size" && visitor.getCM().checkGlobalConstant(sym))
{
const ast::exps_t size_args = ce.getArgs();
if (size_args.size() == 1)
{
ast::Exp * e = size_args[0];
e->accept(visitor);
Result & res = visitor.getResult();
if (res.getType().ismatrix())
{
rows = res.getType().rows;
cols = res.getType().cols;
hasRC = true;
}
}
}
}
}
if (hasRC)
{
const TIType & type = R1.getType();
SymbolicDimension prod1 = type.rows * type.cols;
SymbolicDimension prod2 = rows * cols;
bool res = visitor.getCM().check(ConstraintManager::EQUAL, prod1.getValue(), prod2.getValue());
if (res)
{
TIType resT(visitor.getGVN(), R1.getType().type, rows, cols);
int tempId;
if (R1.getTempId() != -1)
{
tempId = R1.getTempId();
}
else
{
tempId = visitor.getDM().getTmpId(resT, false);
}
Result & _res = e.getDecorator().setResult(Result(resT, tempId));
visitor.setResult(_res);
return true;
}
}
return false;
}
bool MemInitAnalyzer::analyze(AnalysisVisitor & visitor, const unsigned int lhs, ast::CallExp & e)
{
const ast::exps_t args = e.getArgs();
if (args.size() == 2)
{
ast::Exp * first = *args.begin();
ast::Exp * second = *std::next(args.begin());
first->accept(visitor);
Result R1 = visitor.getResult();
visitor.getDM().releaseTmp(R1.getTempId(), first);
second->accept(visitor);
Result & R2 = visitor.getResult();
visitor.getDM().releaseTmp(R2.getTempId(), second);
double val;
SymbolicDimension rows, cols;
bool empty = false;
if (R1.getConstant().getDblValue(val))
{
const int nrows = tools::cast<int>(val);
if (nrows <= 0)
{
empty = true;
}
else
{
rows = SymbolicDimension(visitor.getGVN(), nrows);
}
}
else if (GVN::Value * gvnValue = R1.getConstant().getGVNValue())
{
rows.setValue(gvnValue);
rows.setGVN(&visitor.getGVN());
}
else
{
return false;
}
if (!empty)
{
if (R2.getConstant().getDblValue(val))
{
const int ncols = tools::cast<int>(val);
if (ncols <= 0)
{
empty = true;
}
else
{
cols = SymbolicDimension(visitor.getGVN(), ncols);
}
}
else if (GVN::Value * gvnValue = R2.getConstant().getGVNValue())
{
cols.setValue(gvnValue);
cols.setGVN(&visitor.getGVN());
}
else
{
return false;
}
}
if (empty)
{
e.getDecorator().setResult(TIType(visitor.getGVN(), TIType::EMPTY));
}
else
{
bool res = visitor.getCM().check(ConstraintManager::POSITIVE, rows.getValue());
if (res)
{
res = visitor.getCM().check(ConstraintManager::POSITIVE, cols.getValue());
if (!res)
{
return false;
}
}
else
{
return false;
}
TIType resT(visitor.getGVN(), TIType::DOUBLE, rows, cols);
e.getDecorator().setResult(Result(resT, visitor.getDM().getTmpId(resT, false)));
}
visitor.setResult(e.getDecorator().res);
return true;
}
return false;
}
const bool PolymorphicMacroCache::getOutTypes(AnalysisVisitor & visitor, MacroDef * macrodef, std::vector<TIType> & in, std::vector<TIType> & out)
{
// TODO: handle varargin
if (in.size() > macrodef->getRhs())
{
return false;
}
std::vector<TIType> completeIn;
if (!PolymorphicMacroCache::getCompleteIn(*macrodef, visitor, in, completeIn))
{
return false;
}
MacroSignature signature(*macrodef, out.size(), completeIn);
MacroSignMap::iterator i = signatures.find(signature);
if (i == signatures.end())
{
i = signatures.emplace(signature, 0).first;
}
CompleteMacroSignature & cms = i->second;
std::vector<GVN::Value *> values;
std::vector<const MultivariatePolynomial *> polys;
for (auto & t : completeIn)
{
if (t.isscalar())
{
GVN::Value * v = t.rows.getValue();
values.emplace_back(v);
polys.emplace_back(v->poly);
}
else
{
GVN::Value * v = t.rows.getValue();
values.emplace_back(v);
polys.emplace_back(v->poly);
v = t.cols.getValue();
values.emplace_back(v);
polys.emplace_back(v->poly);
}
}
const MacroOut * mout = cms.getOutTypes(visitor, signature, macrodef, visitor.getDM(), in.size(), completeIn, values);
if (mout)
{
std::vector<TIType>::iterator i = out.begin();
for (const auto & t : mout->tuple.types)
{
*i = t;
GVN::Value * Rv = getValue(t.rows.getValue(), visitor, polys, mout->maxVarId);
GVN::Value * Cv = getValue(t.cols.getValue(), visitor, polys, mout->maxVarId);
i->rows.setValue(Rv);
i->cols.setValue(Cv);
i->invalidScalar();
++i;
}
//out.assign(mout->tuple.types.begin(), mout->tuple.types.end());
return true;
}
else
{
return false;
}
}
bool SizeAnalyzer::analyze(AnalysisVisitor & visitor, const unsigned int lhs, ast::CallExp & e)
{
if (lhs > 2)
{
return false;
}
const ast::exps_t args = e.getArgs();
enum Kind
{
ROWS, COLS, ROWSTIMESCOLS, ROWSCOLS, ONE, BOTH, DUNNO
} kind = DUNNO;
const std::size_t size = args.size();
if (size == 0 || size >= 3)
{
return false;
}
ast::Exp * first = *args.begin();
if (!first)
{
return false;
}
first->accept(visitor);
Result & res = visitor.getResult();
if (!res.getType().ismatrix())
{
visitor.getDM().releaseTmp(res.getTempId(), first);
return false;
}
switch (size)
{
case 1:
if (lhs == 1)
{
kind = BOTH;
}
else if (lhs == 2)
{
kind = ROWSCOLS;
}
break;
case 2:
{
ast::Exp * second = *std::next(args.begin());
if (second && lhs == 1)
{
if (second->isStringExp())
{
const std::wstring & arg2 = static_cast<ast::StringExp *>(second)->getValue();
if (arg2 == L"r")
{
kind = ROWS;
}
else if (arg2 == L"c")
{
kind = COLS;
}
else if (arg2 == L"*")
{
kind = ROWSTIMESCOLS;
}
else
{
visitor.getDM().releaseTmp(res.getTempId(), first);
return false;
}
}
else if (second->isDoubleExp())
{
const double arg2 = static_cast<ast::DoubleExp *>(second)->getValue();
if (arg2 == 1)
{
kind = ROWS;
}
else if (arg2 == 2)
{
kind = COLS;
}
else if (arg2 >= 3)
{
// TODO: we should handle hypermatrix
kind = ONE;
}
else
{
visitor.getDM().releaseTmp(res.getTempId(), first);
return false;
}
}
}
else
{
visitor.getDM().releaseTmp(res.getTempId(), first);
return false;
}
break;
}
default:
visitor.getDM().releaseTmp(res.getTempId(), first);
return false;
}
TIType type(visitor.getGVN(), TIType::DOUBLE);
switch (kind)
{
case ROWS:
{
SymbolicDimension & rows = res.getType().rows;
Result & _res = e.getDecorator().setResult(type);
_res.getConstant() = rows.getValue();
e.getDecorator().setCall(new SizeCall(SizeCall::R));
visitor.setResult(_res);
break;
}
case COLS:
{
SymbolicDimension & cols = res.getType().cols;
Result & _res = e.getDecorator().setResult(type);
_res.getConstant() = cols.getValue();
e.getDecorator().setCall(new SizeCall(SizeCall::C));
visitor.setResult(_res);
break;
}
case ROWSTIMESCOLS:
{
SymbolicDimension & rows = res.getType().rows;
SymbolicDimension & cols = res.getType().cols;
SymbolicDimension prod = rows * cols;
Result & _res = e.getDecorator().setResult(type);
_res.getConstant() = prod.getValue();
e.getDecorator().setCall(new SizeCall(SizeCall::RC));
visitor.setResult(_res);
break;
}
case ROWSCOLS:
{
SymbolicDimension & rows = res.getType().rows;
SymbolicDimension & cols = res.getType().cols;
std::vector<Result> & mlhs = visitor.getLHSContainer();
mlhs.clear();
mlhs.reserve(2);
mlhs.emplace_back(type);
mlhs.back().getConstant() = rows.getValue();
mlhs.emplace_back(type);
mlhs.back().getConstant() = cols.getValue();
e.getDecorator().setCall(new SizeCall(SizeCall::R_C));
break;
}
case ONE:
{
Result & _res = e.getDecorator().setResult(type);
_res.getConstant() = new types::Double(1);
e.getDecorator().setCall(new SizeCall(SizeCall::ONE));
visitor.setResult(_res);
break;
}
case BOTH:
{
TIType _type(visitor.getGVN(), TIType::DOUBLE, 1, 2);
Result & _res = e.getDecorator().setResult(_type);
e.getDecorator().setCall(new SizeCall(SizeCall::BOTH));
visitor.setResult(_res);
break;
}
default:
return false;
}
return true;
}
