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(); }