SSATmp* IRBuilder::preOptimizeCheckLoc(IRInstruction* inst) {
auto const locId = inst->extra<CheckLoc>()->locId;
Type typeParam = inst->typeParam();
SSATmp* src = inst->src(0);
if (auto const prevValue = localValue(locId, DataTypeGeneric)) {
return gen(CheckType, typeParam, inst->taken(), prevValue);
}
auto const prevType = localType(locId, DataTypeGeneric);
if (prevType <= typeParam) {
return src;
}
if (prevType.not(typeParam)) {
if (typeParam.isBoxed() && prevType.isBoxed()) {
/* When both types are non-intersecting boxed types, we're just
* updating the inner type hint. This requires no runtime work. */
constrainLocal(locId, DataTypeCountness, "preOptimizeCheckLoc");
return gen(AssertLoc, LocalId(locId), typeParam, src);
}
/* This check will always fail. It's probably due to an incorrect
* prediction. Generate a Jmp, and return the source because
* following instructions may depend on the output of CheckLoc
* (they'll be DCEd later). Note that we can't use convertToJmp
* because the return value isn't nullptr, so the original
* instruction won't be inserted into the stream. */
gen(Jmp, inst->taken());
return src;
}
return nullptr;
}
SSATmp* TraceBuilder::preOptimizeCheckLoc(IRInstruction* inst) {
auto const locId = inst->extra<CheckLoc>()->locId;
Type typeParam = inst->typeParam();
if (auto const prevValue = localValue(locId, DataTypeGeneric)) {
return gen(CheckType, typeParam, inst->taken(), prevValue);
}
auto const prevType = localType(locId, DataTypeSpecific);
if (prevType <= typeParam) {
return inst->src(0);
} else {
//
// Normally, it doesn't make sense to be checking something that's
// deemed to fail. Incompatible boxed types are ok though, since
// we don't track them precisely, but instead check them at every
// use.
//
// However, in JitPGO mode right now, this pathological case can
// happen, because profile counters are not accurate and we
// currently don't analyze Block post-conditions when picking its
// successors during region selection. This can lead to
// incompatible types in blocks selected for the same region.
//
if (!typeParam.isBoxed() || !prevType.isBoxed()) {
if ((typeParam & prevType) == Type::Bottom) {
assert(RuntimeOption::EvalJitPGO);
return gen(Jmp, inst->taken());
}
}
}
return nullptr;
}
SSATmp* IRBuilder::preOptimizeDecRefLoc(IRInstruction* inst) {
auto const locId = inst->extra<DecRefLoc>()->locId;
/*
* Refine the type if we can.
*
* We can't really rely on the types held in the boxed values since aliasing
* stores may change them, and we only guard during LdRef. So we have to
* change any boxed type to BoxedCell.
*
* DataTypeGeneric is used because we don't want a DecRef to be the only
* thing keeping a guard around. This code is designed to tolerate the
* incoming type being relaxed.
*/
auto knownType = localType(locId, DataTypeGeneric);
if (knownType.isBoxed()) {
knownType = Type::BoxedCell;
}
/*
* If we have the local value in flight, use a DecRef on it instead of doing
* it in memory.
*/
if (auto tmp = localValue(locId, DataTypeGeneric)) {
gen(DecRef, tmp);
inst->convertToNop();
return nullptr;
}
if (!typeMightRelax()) {
inst->setTypeParam(std::min(knownType, inst->typeParam()));
}
return nullptr;
}
SSATmp* TraceBuilder::preOptimizeDecRefLoc(IRInstruction* inst) {
auto const locId = inst->extra<DecRefLoc>()->locId;
/*
* Refine the type if we can.
*
* We can't really rely on the types held in the boxed values since
* aliasing stores may change them, and we only guard during LdRef.
* So we have to change any boxed type to BoxedCell.
*/
auto knownType = localType(locId, DataTypeCountness);
if (knownType.isBoxed()) {
knownType = Type::BoxedCell;
}
if (knownType != Type::None) { // TODO(#2135185)
inst->setTypeParam(
Type::mostRefined(knownType, inst->typeParam())
);
}
/*
* If we have the local value in flight, use a DecRef on it instead
* of doing it in memory.
*/
if (auto tmp = localValue(locId, DataTypeCountness)) {
gen(DecRef, tmp);
inst->convertToNop();
}
return nullptr;
}
SSATmp* TraceBuilder::preOptimizeLdLoc(IRInstruction* inst) {
auto const locId = inst->extra<LdLoc>()->locId;
if (auto tmp = localValue(locId, DataTypeGeneric)) {
return tmp;
}
auto const type = localType(locId, DataTypeGeneric);
if (!type.equals(Type::None)) { // TODO(#2135185)
inst->setTypeParam(Type::mostRefined(type, inst->typeParam()));
}
return nullptr;
}
SSATmp* IRBuilder::preOptimizeLdLoc(IRInstruction* inst) {
auto const locId = inst->extra<LdLoc>()->locId;
if (auto tmp = localValue(locId, DataTypeGeneric)) {
return tmp;
}
auto const type = localType(locId, DataTypeGeneric);
// If FrameState's type isn't as good as the type param, we're missing
// information in the IR.
assert(inst->typeParam() >= type);
inst->setTypeParam(Type::mostRefined(type, inst->typeParam()));
return nullptr;
}
SSATmp* IRBuilder::preOptimizeAssertLoc(IRInstruction* inst) {
auto const locId = inst->extra<AssertLoc>()->locId;
if (auto const prevValue = localValue(locId, DataTypeGeneric)) {
return gen(AssertType, inst->typeParam(), prevValue);
}
return m_simplifier.simplifyAssertTypeOp(
inst, localType(locId, DataTypeGeneric), [&](TypeConstraint tc) {
constrainLocal(locId, tc, "preOptimizeAssertLoc");
}
);
}
QVariant CoreSettings::coreState(const QVariant &def)
{
return localValue("CoreState", def);
}
// FIXME remove
QVariant CoreSettings::oldDbSettings()
{
return localValue("DatabaseSettings");
}
QVariant CoreSettings::storageSettings(const QVariant &def)
{
return localValue("StorageSettings", def);
}
bool WarningsSettings::showWarning(const QString &key)
{
return localValue(key, true).toBool();
}
/** Applies the current network configuration settings to Tor. If
* <b>errmsg</b> is specified and an error occurs while applying the settings,
* it will be set to a string describing the error. */
bool
NetworkSettings::apply(QString *errmsg)
{
QMultiHash<QString, QString> conf;
quint32 torVersion = torControl()->getTorVersion();
conf.insert(SETTING_REACHABLE_ADDRESSES,
(getFascistFirewall() ?
localValue(SETTING_REACHABLE_ADDRESSES).toStringList().join(",") : ""));
QString socks4, socks5, http, https;
QString addr, user, pass, auth;
addr = localValue(SETTING_PROXY_ADDRESS).toString();
user = localValue(SETTING_PROXY_USERNAME).toString();
pass = localValue(SETTING_PROXY_PASSWORD).toString();
if (!user.isEmpty() || !pass.isEmpty())
auth = QString("%1:%2").arg(user).arg(pass);
switch (getProxyType()) {
case NoProxy:
break;
case Socks4Proxy:
socks4 = addr;
break;
case Socks5Proxy:
socks5 = addr;
break;
case HttpHttpsProxy:
http = addr;
https = http;
break;
}
if (torVersion >= 0x020201) {
/* SOCKS support was implemented in 0.2.2.1 */
conf.insert(SETTING_SOCKS4_PROXY, socks4);
conf.insert(SETTING_SOCKS5_PROXY, socks5);
conf.insert(SETTING_SOCKS5_USERNAME, user);
conf.insert(SETTING_SOCKS5_PASSWORD, pass);
}
conf.insert(SETTING_HTTPS_PROXY, https);
conf.insert(SETTING_HTTPS_PROXY_AUTH, auth);
if (getUseBridges()) {
/* We want to always enable TunnelDirConns and friends when using
* bridge relays. */
conf.insert(SETTING_TUNNEL_DIR_CONNS, "1");
conf.insert(SETTING_PREFER_TUNNELED_DIR_CONNS, "1");
} else if (torVersion <= 0x020021) {
/* TunnelDirConns is enabled by default on Tor >= 0.2.0.22-rc, so don't
* disable it if our Tor is recent enough. */
conf.insert(SETTING_TUNNEL_DIR_CONNS, "0");
conf.insert(SETTING_PREFER_TUNNELED_DIR_CONNS, "0");
}
if (torVersion >= 0x020003) {
/* Do the bridge stuff only on Tor >= 0.2.0.3-alpha */
QStringList bridges = localValue(SETTING_BRIDGE_LIST).toStringList();
if (getUseBridges() && !bridges.isEmpty()) {
conf.insert(SETTING_USE_BRIDGES, "1");
conf.insert(SETTING_UPDATE_BRIDGES, "1");
foreach (QString bridge, bridges) {
conf.insert(SETTING_BRIDGE_LIST, bridge);
}
QTextCharFormat UiStyleSettings::customFormat(UiStyle::FormatType ftype)
{
return localValue(QString("Format/%1").arg(ftype), QTextFormat()).value<QTextFormat>().toCharFormat();
}
void Settings::initAndNotify(const QString &key, QObject *receiver, const char *slot, const QVariant &defaultValue) {
notify(key, receiver, slot);
emit notifier(normalizedKey(group, key))->valueChanged(localValue(key, defaultValue));
}
QVariant CoreSettings::authSettings(const QVariant &def)
{
return localValue("AuthSettings", def);
}
