bool DataBus::GetClientMethodParameterInfoResponsePacket::create(const quint8 source,
const quint8 destination,
const quint8 packetId,
const quint8 methodId,
const quint8 parameterIndex,
const ValueInfo ¶meterInfo,
Packet *packet)
{
// Check parameters
if ((destination == 0) ||
(parameterInfo.isValid() == false) ||
(packet == 0))
{
// Error, invalid parameters
return false;
}
// Create Header
packet->setSource(source);
packet->setDestination(destination);
packet->setPacketType(PacketType_GetClientMethodParameterInfoResponse);
packet->setPacketId(packetId);
// Create Payload
packet->setData(QByteArray(1, static_cast<char>(methodId)));
packet->setData(QByteArray(1, static_cast<char>(parameterIndex)));
packet->setData(parameterInfo.toBinary());
// Success
return true;
}
void FunctionImportGlobalProcessing::processGlobalForThinLTO(GlobalValue &GV) {
// Check the summaries to see if the symbol gets resolved to a known local
// definition.
if (GV.hasName()) {
ValueInfo VI = ImportIndex.getValueInfo(GV.getGUID());
if (VI) {
// Need to check all summaries are local in case of hash collisions.
bool IsLocal = VI.getSummaryList().size() &&
llvm::all_of(VI.getSummaryList(),
[](const std::unique_ptr<GlobalValueSummary> &Summary) {
return Summary->isDSOLocal();
});
if (IsLocal)
GV.setDSOLocal(true);
}
}
bool DoPromote = false;
if (GV.hasLocalLinkage() &&
((DoPromote = shouldPromoteLocalToGlobal(&GV)) || isPerformingImport())) {
// Once we change the name or linkage it is difficult to determine
// again whether we should promote since shouldPromoteLocalToGlobal needs
// to locate the summary (based on GUID from name and linkage). Therefore,
// use DoPromote result saved above.
GV.setName(getName(&GV, DoPromote));
GV.setLinkage(getLinkage(&GV, DoPromote));
if (!GV.hasLocalLinkage())
GV.setVisibility(GlobalValue::HiddenVisibility);
} else
GV.setLinkage(getLinkage(&GV, /* DoPromote */ false));
// Remove functions imported as available externally defs from comdats,
// as this is a declaration for the linker, and will be dropped eventually.
// It is illegal for comdats to contain declarations.
auto *GO = dyn_cast_or_null<GlobalObject>(&GV);
if (GO && GO->isDeclarationForLinker() && GO->hasComdat()) {
// The IRMover should not have placed any imported declarations in
// a comdat, so the only declaration that should be in a comdat
// at this point would be a definition imported as available_externally.
assert(GO->hasAvailableExternallyLinkage() &&
"Expected comdat on definition (possibly available external)");
GO->setComdat(nullptr);
}
}
void
GlobOpt::CaptureValue(BasicBlock *block, StackSym * stackSym, Value * value, BailOutInfo * bailOutInfo)
{
if (!this->func->DoGlobOptsForGeneratorFunc())
{
// TODO[generators][ianhall]: Enable constprop and copyprop for generator functions; see GlobOpt::CopyProp()
// Even though CopyProp is disabled for generator functions we must also not put the copy-prop sym into the
// bailOutInfo so that the bailOutInfo keeps track of the key sym in its byteCodeUpwardExposed list.
return;
}
ValueInfo * valueInfo = value->GetValueInfo();
Assert(stackSym->HasByteCodeRegSlot() || stackSym->HasArgSlotNum());
Assert(!stackSym->IsTypeSpec());
int32 intConstantValue;
if (valueInfo->TryGetIntConstantValue(&intConstantValue))
{
BailoutConstantValue constValue;
constValue.InitIntConstValue(intConstantValue);
bailOutInfo->capturedValues.constantValues.PrependNode(this->func->m_alloc, stackSym, constValue);
}
else if (valueInfo->IsVarConstant())
{
BailoutConstantValue constValue;
constValue.InitVarConstValue(valueInfo->AsVarConstant()->VarValue());
bailOutInfo->capturedValues.constantValues.PrependNode(this->func->m_alloc, stackSym, constValue);
}
else
{
StackSym * copyPropSym = this->GetCopyPropSym(block, stackSym, value);
if (copyPropSym)
{
bailOutInfo->capturedValues.copyPropSyms.PrependNode(this->func->m_alloc, stackSym, copyPropSym);
}
}
}
void FunctionImportGlobalProcessing::processGlobalForThinLTO(GlobalValue &GV) {
ValueInfo VI;
if (GV.hasName()) {
VI = ImportIndex.getValueInfo(GV.getGUID());
// Set synthetic function entry counts.
if (VI && ImportIndex.hasSyntheticEntryCounts()) {
if (Function *F = dyn_cast<Function>(&GV)) {
if (!F->isDeclaration()) {
for (auto &S : VI.getSummaryList()) {
FunctionSummary *FS = dyn_cast<FunctionSummary>(S->getBaseObject());
if (FS->modulePath() == M.getModuleIdentifier()) {
F->setEntryCount(Function::ProfileCount(FS->entryCount(),
Function::PCT_Synthetic));
break;
}
}
}
}
}
// Check the summaries to see if the symbol gets resolved to a known local
// definition.
if (VI && VI.isDSOLocal()) {
GV.setDSOLocal(true);
if (GV.hasDLLImportStorageClass())
GV.setDLLStorageClass(GlobalValue::DefaultStorageClass);
}
}
// Mark read-only variables which can be imported with specific attribute.
// We can't internalize them now because IRMover will fail to link variable
// definitions to their external declarations during ThinLTO import. We'll
// internalize read-only variables later, after import is finished.
// See internalizeImmutableGVs.
//
// If global value dead stripping is not enabled in summary then
// propagateConstants hasn't been run. We can't internalize GV
// in such case.
if (!GV.isDeclaration() && VI && ImportIndex.withGlobalValueDeadStripping()) {
const auto &SL = VI.getSummaryList();
auto *GVS = SL.empty() ? nullptr : dyn_cast<GlobalVarSummary>(SL[0].get());
if (GVS && GVS->isReadOnly())
cast<GlobalVariable>(&GV)->addAttribute("thinlto-internalize");
}
bool DoPromote = false;
if (GV.hasLocalLinkage() &&
((DoPromote = shouldPromoteLocalToGlobal(&GV)) || isPerformingImport())) {
// Save the original name string before we rename GV below.
auto Name = GV.getName().str();
// Once we change the name or linkage it is difficult to determine
// again whether we should promote since shouldPromoteLocalToGlobal needs
// to locate the summary (based on GUID from name and linkage). Therefore,
// use DoPromote result saved above.
GV.setName(getName(&GV, DoPromote));
GV.setLinkage(getLinkage(&GV, DoPromote));
if (!GV.hasLocalLinkage())
GV.setVisibility(GlobalValue::HiddenVisibility);
// If we are renaming a COMDAT leader, ensure that we record the COMDAT
// for later renaming as well. This is required for COFF.
if (const auto *C = GV.getComdat())
if (C->getName() == Name)
RenamedComdats.try_emplace(C, M.getOrInsertComdat(GV.getName()));
} else
GV.setLinkage(getLinkage(&GV, /* DoPromote */ false));
// Remove functions imported as available externally defs from comdats,
// as this is a declaration for the linker, and will be dropped eventually.
// It is illegal for comdats to contain declarations.
auto *GO = dyn_cast<GlobalObject>(&GV);
if (GO && GO->isDeclarationForLinker() && GO->hasComdat()) {
// The IRMover should not have placed any imported declarations in
// a comdat, so the only declaration that should be in a comdat
// at this point would be a definition imported as available_externally.
assert(GO->hasAvailableExternallyLinkage() &&
"Expected comdat on definition (possibly available external)");
GO->setComdat(nullptr);
}
}
// Write definition of external node, which doesn't have any
// specific module associated with it. Typically this is function
// or variable defined in native object or library.
static void defineExternalNode(raw_ostream &OS, const char *Pfx,
const ValueInfo &VI) {
auto StrId = std::to_string(VI.getGUID());
OS << " " << StrId << " [label=\"" << getNodeVisualName(VI)
<< "\"]; // defined externally\n";
}
static std::string getNodeVisualName(const ValueInfo &VI) {
return VI.name().empty() ? std::string("@") + std::to_string(VI.getGUID())
: VI.name().str();
}
