2020-09-05 16:37:37 -04:00
|
|
|
#include "Val.h"
|
2020-09-06 12:45:31 -04:00
|
|
|
#include "Env.h"
|
2020-09-06 16:58:25 -04:00
|
|
|
#include "IR.h"
|
2020-09-05 16:37:37 -04:00
|
|
|
|
|
|
|
/*!
|
|
|
|
* Fallback to_gpr if a more optimized one is not provided.
|
|
|
|
*/
|
2020-09-07 13:28:16 -04:00
|
|
|
RegVal* Val::to_gpr(Env* fe) {
|
2020-09-13 10:40:21 -04:00
|
|
|
// TODO - handle 128-bit stuff here!
|
2020-09-06 12:45:31 -04:00
|
|
|
auto rv = to_reg(fe);
|
2020-09-06 16:58:25 -04:00
|
|
|
if (rv->ireg().kind == emitter::RegKind::GPR) {
|
2020-09-06 12:45:31 -04:00
|
|
|
return rv;
|
|
|
|
} else {
|
2020-09-13 10:40:21 -04:00
|
|
|
auto re = fe->make_gpr(m_ts);
|
|
|
|
fe->emit(std::make_unique<IR_RegSet>(re, rv));
|
|
|
|
return re;
|
2020-09-06 12:45:31 -04:00
|
|
|
}
|
2020-09-05 16:37:37 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* Fallback to_xmm if a more optimized one is not provided.
|
|
|
|
*/
|
2020-09-07 13:28:16 -04:00
|
|
|
RegVal* Val::to_xmm(Env* fe) {
|
2020-09-13 17:34:02 -04:00
|
|
|
auto rv = to_reg(fe);
|
|
|
|
if (rv->ireg().kind == emitter::RegKind::XMM) {
|
|
|
|
return rv;
|
|
|
|
} else {
|
2020-09-13 21:10:43 -04:00
|
|
|
throw std::runtime_error("Register is not an XMM[0-15] register.");
|
2020-09-13 17:34:02 -04:00
|
|
|
}
|
2020-09-05 16:37:37 -04:00
|
|
|
}
|
|
|
|
|
2020-09-07 13:28:16 -04:00
|
|
|
RegVal* RegVal::to_reg(Env* fe) {
|
2020-09-05 18:55:07 -04:00
|
|
|
(void)fe;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2020-09-07 13:28:16 -04:00
|
|
|
RegVal* RegVal::to_gpr(Env* fe) {
|
2020-09-05 16:37:37 -04:00
|
|
|
(void)fe;
|
2020-09-06 16:58:25 -04:00
|
|
|
if (m_ireg.kind == emitter::RegKind::GPR) {
|
2020-09-05 18:55:07 -04:00
|
|
|
return this;
|
|
|
|
} else {
|
2020-09-13 17:34:02 -04:00
|
|
|
auto re = fe->make_gpr(m_ts);
|
|
|
|
fe->emit(std::make_unique<IR_RegSet>(re, this));
|
|
|
|
return re;
|
2020-09-05 18:55:07 -04:00
|
|
|
}
|
2020-09-05 16:37:37 -04:00
|
|
|
}
|
2020-09-05 18:55:07 -04:00
|
|
|
|
2020-09-07 13:28:16 -04:00
|
|
|
RegVal* RegVal::to_xmm(Env* fe) {
|
2020-09-05 18:55:07 -04:00
|
|
|
(void)fe;
|
2020-09-06 16:58:25 -04:00
|
|
|
if (m_ireg.kind == emitter::RegKind::XMM) {
|
2020-09-05 18:55:07 -04:00
|
|
|
return this;
|
|
|
|
} else {
|
2020-09-13 17:34:02 -04:00
|
|
|
auto re = fe->make_xmm(m_ts);
|
|
|
|
fe->emit(std::make_unique<IR_RegSet>(re, this));
|
|
|
|
return re;
|
2020-09-05 18:55:07 -04:00
|
|
|
}
|
2020-09-06 12:45:31 -04:00
|
|
|
}
|
|
|
|
|
2020-09-07 13:28:16 -04:00
|
|
|
RegVal* IntegerConstantVal::to_reg(Env* fe) {
|
2020-09-06 12:45:31 -04:00
|
|
|
auto rv = fe->make_gpr(m_ts);
|
|
|
|
fe->emit(std::make_unique<IR_LoadConstant64>(rv, m_value));
|
|
|
|
return rv;
|
2020-09-07 13:28:16 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
RegVal* SymbolVal::to_reg(Env* fe) {
|
|
|
|
auto re = fe->make_gpr(m_ts);
|
|
|
|
fe->emit(std::make_unique<IR_LoadSymbolPointer>(re, m_name));
|
|
|
|
return re;
|
|
|
|
}
|
|
|
|
|
|
|
|
RegVal* SymbolValueVal::to_reg(Env* fe) {
|
|
|
|
auto re = fe->make_gpr(m_ts);
|
|
|
|
fe->emit(std::make_unique<IR_GetSymbolValue>(re, m_sym, m_sext));
|
|
|
|
return re;
|
2020-09-12 13:11:42 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
RegVal* StaticVal::to_reg(Env* fe) {
|
|
|
|
auto re = fe->make_gpr(m_ts);
|
|
|
|
fe->emit(std::make_unique<IR_StaticVarAddr>(re, obj));
|
|
|
|
return re;
|
|
|
|
}
|
|
|
|
|
|
|
|
RegVal* LambdaVal::to_reg(Env* fe) {
|
|
|
|
auto re = fe->make_gpr(m_ts);
|
|
|
|
assert(func);
|
|
|
|
fe->emit(std::make_unique<IR_FunctionAddr>(re, func));
|
|
|
|
return re;
|
2020-09-13 10:40:21 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
RegVal* FloatConstantVal::to_reg(Env* fe) {
|
|
|
|
auto re = fe->make_xmm(m_ts);
|
|
|
|
fe->emit(std::make_unique<IR_StaticVarLoad>(re, m_value));
|
|
|
|
return re;
|
2020-09-17 21:47:52 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
RegVal* MemoryOffsetConstantVal::to_reg(Env* fe) {
|
|
|
|
auto re = fe->make_gpr(deref_type);
|
|
|
|
fe->emit(std::make_unique<IR_LoadConstOffset>(re, offset, base, info));
|
|
|
|
return re;
|
2020-09-05 18:55:07 -04:00
|
|
|
}
|