CanGenericSignature GenericSignature::getCanonical( ArrayRef<GenericTypeParamType *> params, ArrayRef<Requirement> requirements) { // Canonicalize the parameters and requirements. SmallVector<GenericTypeParamType*, 8> canonicalParams; canonicalParams.reserve(params.size()); for (auto param : params) { canonicalParams.push_back(cast<GenericTypeParamType>(param->getCanonicalType())); } SmallVector<Requirement, 8> canonicalRequirements; canonicalRequirements.reserve(requirements.size()); for (auto &reqt : requirements) { if (reqt.getKind() != RequirementKind::Layout) { auto secondTy = reqt.getSecondType(); canonicalRequirements.push_back( Requirement(reqt.getKind(), reqt.getFirstType()->getCanonicalType(), secondTy ? secondTy->getCanonicalType() : CanType())); } else canonicalRequirements.push_back( Requirement(reqt.getKind(), reqt.getFirstType()->getCanonicalType(), reqt.getLayoutConstraint())); } auto canSig = get(canonicalParams, canonicalRequirements, /*isKnownCanonical=*/true); return CanGenericSignature(canSig); }
void llvm::appendToGlobalCtors(Module &M, Function *F, int Priority) { IRBuilder<> IRB(M.getContext()); FunctionType *FnTy = FunctionType::get(IRB.getVoidTy(), false); StructType *Ty = StructType::get( IRB.getInt32Ty(), PointerType::getUnqual(FnTy), NULL); Constant *RuntimeCtorInit = ConstantStruct::get( Ty, IRB.getInt32(Priority), F, NULL); // Get the current set of static global constructors and add the new ctor // to the list. SmallVector<Constant *, 16> CurrentCtors; if (GlobalVariable * GVCtor = M.getNamedGlobal("llvm.global_ctors")) { if (Constant *Init = GVCtor->getInitializer()) { unsigned n = Init->getNumOperands(); CurrentCtors.reserve(n + 1); for (unsigned i = 0; i != n; ++i) CurrentCtors.push_back(cast<Constant>(Init->getOperand(i))); } GVCtor->eraseFromParent(); } CurrentCtors.push_back(RuntimeCtorInit); // Create a new initializer. ArrayType *AT = ArrayType::get(RuntimeCtorInit->getType(), CurrentCtors.size()); Constant *NewInit = ConstantArray::get(AT, CurrentCtors); // Create the new global variable and replace all uses of // the old global variable with the new one. (void)new GlobalVariable(M, NewInit->getType(), false, GlobalValue::AppendingLinkage, NewInit, "llvm.global_ctors"); }
void RenameIndependentSubregs::distribute(const IntEqClasses &Classes, const SmallVectorImpl<SubRangeInfo> &SubRangeInfos, const SmallVectorImpl<LiveInterval*> &Intervals) const { unsigned NumClasses = Classes.getNumClasses(); SmallVector<unsigned, 8> VNIMapping; SmallVector<LiveInterval::SubRange*, 8> SubRanges; BumpPtrAllocator &Allocator = LIS->getVNInfoAllocator(); for (const SubRangeInfo &SRInfo : SubRangeInfos) { LiveInterval::SubRange &SR = *SRInfo.SR; unsigned NumValNos = SR.valnos.size(); VNIMapping.clear(); VNIMapping.reserve(NumValNos); SubRanges.clear(); SubRanges.resize(NumClasses-1, nullptr); for (unsigned I = 0; I < NumValNos; ++I) { const VNInfo &VNI = *SR.valnos[I]; unsigned LocalID = SRInfo.ConEQ.getEqClass(&VNI); unsigned ID = Classes[LocalID + SRInfo.Index]; VNIMapping.push_back(ID); if (ID > 0 && SubRanges[ID-1] == nullptr) SubRanges[ID-1] = Intervals[ID]->createSubRange(Allocator, SR.LaneMask); } DistributeRange(SR, SubRanges.data(), VNIMapping); } }
// Propagate existing explicit probabilities from either profile data or // 'expect' intrinsic processing. bool BranchProbabilityAnalysis::calcMetadataWeights(BasicBlock *BB) { TerminatorInst *TI = BB->getTerminator(); if (TI->getNumSuccessors() == 1) return false; if (!isa<BranchInst>(TI) && !isa<SwitchInst>(TI)) return false; MDNode *WeightsNode = TI->getMetadata(LLVMContext::MD_prof); if (!WeightsNode) return false; // Ensure there are weights for all of the successors. Note that the first // operand to the metadata node is a name, not a weight. if (WeightsNode->getNumOperands() != TI->getNumSuccessors() + 1) return false; // Build up the final weights that will be used in a temporary buffer, but // don't add them until all weihts are present. Each weight value is clamped // to [1, getMaxWeightFor(BB)]. uint32_t WeightLimit = getMaxWeightFor(BB); SmallVector<uint32_t, 2> Weights; Weights.reserve(TI->getNumSuccessors()); for (unsigned i = 1, e = WeightsNode->getNumOperands(); i != e; ++i) { ConstantInt *Weight = dyn_cast<ConstantInt>(WeightsNode->getOperand(i)); if (!Weight) return false; Weights.push_back( std::max<uint32_t>(1, Weight->getLimitedValue(WeightLimit))); } assert(Weights.size() == TI->getNumSuccessors() && "Checked above"); for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i) BP->setEdgeWeight(BB, TI->getSuccessor(i), Weights[i]); return true; }
void CallGraph::print(raw_ostream &OS) const { OS << "CallGraph Root is: "; if (Function *F = Root->getFunction()) OS << F->getName() << "\n"; else { OS << "<<null function: 0x" << Root << ">>\n"; } // Print in a deterministic order by sorting CallGraphNodes by name. We do // this here to avoid slowing down the non-printing fast path. SmallVector<CallGraphNode *, 16> Nodes; Nodes.reserve(FunctionMap.size()); for (auto I = begin(), E = end(); I != E; ++I) Nodes.push_back(I->second.get()); std::sort(Nodes.begin(), Nodes.end(), [](CallGraphNode *LHS, CallGraphNode *RHS) { if (Function *LF = LHS->getFunction()) if (Function *RF = RHS->getFunction()) return LF->getName() < RF->getName(); return RHS->getFunction() != nullptr; }); for (CallGraphNode *CN : Nodes) CN->print(OS); }
/// \brief Try to simplify a call site. /// /// Takes a concrete function and callsite and tries to actually simplify it by /// analyzing the arguments and call itself with instsimplify. Returns true if /// it has simplified the callsite to some other entity (a constant), making it /// free. bool CallAnalyzer::simplifyCallSite(Function *F, CallSite CS) { // FIXME: Using the instsimplify logic directly for this is inefficient // because we have to continually rebuild the argument list even when no // simplifications can be performed. Until that is fixed with remapping // inside of instsimplify, directly constant fold calls here. if (!canConstantFoldCallTo(F)) return false; // Try to re-map the arguments to constants. SmallVector<Constant *, 4> ConstantArgs; ConstantArgs.reserve(CS.arg_size()); for (CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); I != E; ++I) { Constant *C = dyn_cast<Constant>(*I); if (!C) C = dyn_cast_or_null<Constant>(SimplifiedValues.lookup(*I)); if (!C) return false; // This argument doesn't map to a constant. ConstantArgs.push_back(C); } if (Constant *C = ConstantFoldCall(F, ConstantArgs)) { SimplifiedValues[CS.getInstruction()] = C; return true; } return false; }
void ExprEngine::evalArguments(ConstExprIterator AI, ConstExprIterator AE, const FunctionProtoType *FnType, ExplodedNode *Pred, ExplodedNodeSet &Dst, bool FstArgAsLValue) { SmallVector<CallExprWLItem, 20> WorkList; WorkList.reserve(AE - AI); WorkList.push_back(CallExprWLItem(AI, Pred)); while (!WorkList.empty()) { CallExprWLItem Item = WorkList.back(); WorkList.pop_back(); if (Item.I == AE) { Dst.insert(Item.N); continue; } // Evaluate the argument. ExplodedNodeSet Tmp; if (FstArgAsLValue) { FstArgAsLValue = false; } Visit(*Item.I, Item.N, Tmp); ++(Item.I); for (ExplodedNodeSet::iterator NI=Tmp.begin(), NE=Tmp.end(); NI != NE; ++NI) WorkList.push_back(CallExprWLItem(Item.I, *NI)); } }
llvm::Constant* CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral* E) { //assert(!E->getType()->isPointerType() && "Strings are always arrays"); // TEMP only handle 1 byte per char SmallString<64> Str(E->getValue()); Str.resize(E->getByteLength()); //return llvm::ConstantDataArray::getString(context, Str, false); return llvm::ConstantDataArray::getString(context, Str, true); // add 0 #if 0 // Don't emit it as the address of the string, emit the string data itself // as an inline array. if (E->getCharByteWidth() == 1) { SmallString<64> Str(E->getString()); // Resize the string to the right size, which is indicated by its type. const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType()); Str.resize(CAT->getSize().getZExtValue()); return llvm::ConstantDataArray::getString(VMContext, Str, false); } llvm::ArrayType *AType = cast<llvm::ArrayType>(getTypes().ConvertType(E->getType())); llvm::Type *ElemTy = AType->getElementType(); unsigned NumElements = AType->getNumElements(); // Wide strings have either 2-byte or 4-byte elements. if (ElemTy->getPrimitiveSizeInBits() == 16) { SmallVector<uint16_t, 32> Elements; Elements.reserve(NumElements); for(unsigned i = 0, e = E->getLength(); i != e; ++i) Elements.push_back(E->getCodeUnit(i)); Elements.resize(NumElements); return llvm::ConstantDataArray::get(VMContext, Elements); } assert(ElemTy->getPrimitiveSizeInBits() == 32); SmallVector<uint32_t, 32> Elements; Elements.reserve(NumElements); for(unsigned i = 0, e = E->getLength(); i != e; ++i) Elements.push_back(E->getCodeUnit(i)); Elements.resize(NumElements); return llvm::ConstantDataArray::get(VMContext, Elements); #endif }
void Mapper::remapInstruction(Instruction *I) { // Remap operands. for (Use &Op : I->operands()) { Value *V = mapValue(Op); // If we aren't ignoring missing entries, assert that something happened. if (V) Op = V; else assert((Flags & RF_IgnoreMissingLocals) && "Referenced value not in value map!"); } // Remap phi nodes' incoming blocks. if (PHINode *PN = dyn_cast<PHINode>(I)) { for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { Value *V = mapValue(PN->getIncomingBlock(i)); // If we aren't ignoring missing entries, assert that something happened. if (V) PN->setIncomingBlock(i, cast<BasicBlock>(V)); else assert((Flags & RF_IgnoreMissingLocals) && "Referenced block not in value map!"); } } // Remap attached metadata. SmallVector<std::pair<unsigned, MDNode *>, 4> MDs; I->getAllMetadata(MDs); for (const auto &MI : MDs) { MDNode *Old = MI.second; MDNode *New = cast_or_null<MDNode>(mapMetadata(Old)); if (New != Old) I->setMetadata(MI.first, New); } if (!TypeMapper) return; // If the instruction's type is being remapped, do so now. if (auto CS = CallSite(I)) { SmallVector<Type *, 3> Tys; FunctionType *FTy = CS.getFunctionType(); Tys.reserve(FTy->getNumParams()); for (Type *Ty : FTy->params()) Tys.push_back(TypeMapper->remapType(Ty)); CS.mutateFunctionType(FunctionType::get( TypeMapper->remapType(I->getType()), Tys, FTy->isVarArg())); return; } if (auto *AI = dyn_cast<AllocaInst>(I)) AI->setAllocatedType(TypeMapper->remapType(AI->getAllocatedType())); if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) { GEP->setSourceElementType( TypeMapper->remapType(GEP->getSourceElementType())); GEP->setResultElementType( TypeMapper->remapType(GEP->getResultElementType())); } I->mutateType(TypeMapper->remapType(I->getType())); }
// Add an operand to an existing MDNode. The new operand will be added at the // back of the operand list. static void AddOperand(DICompileUnit CU, DIArray SPs, Metadata *NewSP) { SmallVector<Metadata *, 16> NewSPs; NewSPs.reserve(SPs->getNumOperands() + 1); for (unsigned I = 0, E = SPs->getNumOperands(); I != E; ++I) NewSPs.push_back(SPs->getOperand(I)); NewSPs.push_back(NewSP); CU.replaceSubprograms(DIArray(MDNode::get(CU->getContext(), NewSPs))); }
LLVMContextImpl::~LLVMContextImpl() { // NOTE: We need to delete the contents of OwnedModules, but we have to // duplicate it into a temporary vector, because the destructor of Module // will try to remove itself from OwnedModules set. This would cause // iterator invalidation if we iterated on the set directly. std::vector<Module*> Modules(OwnedModules.begin(), OwnedModules.end()); DeleteContainerPointers(Modules); // Free the constants. This is important to do here to ensure that they are // freed before the LeakDetector is torn down. std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(), DropReferences()); std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(), DropFirst()); std::for_each(StructConstants.map_begin(), StructConstants.map_end(), DropFirst()); std::for_each(VectorConstants.map_begin(), VectorConstants.map_end(), DropFirst()); ExprConstants.freeConstants(); ArrayConstants.freeConstants(); StructConstants.freeConstants(); VectorConstants.freeConstants(); DeleteContainerSeconds(CAZConstants); DeleteContainerSeconds(CPNConstants); DeleteContainerSeconds(UVConstants); InlineAsms.freeConstants(); DeleteContainerSeconds(IntConstants); DeleteContainerSeconds(FPConstants); for (StringMap<ConstantDataSequential*>::iterator I = CDSConstants.begin(), E = CDSConstants.end(); I != E; ++I) delete I->second; CDSConstants.clear(); // Destroy attributes. for (FoldingSetIterator<AttributesImpl> I = AttrsSet.begin(), E = AttrsSet.end(); I != E;) { FoldingSetIterator<AttributesImpl> Elem = I++; delete &*Elem; } // Destroy MDNodes. ~MDNode can move and remove nodes between the MDNodeSet // and the NonUniquedMDNodes sets, so copy the values out first. SmallVector<MDNode*, 8> MDNodes; MDNodes.reserve(MDNodeSet.size() + NonUniquedMDNodes.size()); for (FoldingSetIterator<MDNode> I = MDNodeSet.begin(), E = MDNodeSet.end(); I != E; ++I) MDNodes.push_back(&*I); MDNodes.append(NonUniquedMDNodes.begin(), NonUniquedMDNodes.end()); for (SmallVectorImpl<MDNode *>::iterator I = MDNodes.begin(), E = MDNodes.end(); I != E; ++I) (*I)->destroy(); assert(MDNodeSet.empty() && NonUniquedMDNodes.empty() && "Destroying all MDNodes didn't empty the Context's sets."); // Destroy MDStrings. DeleteContainerSeconds(MDStringCache); }
TypeRepr *CloneVisitor::visitCompoundIdentTypeRepr(CompoundIdentTypeRepr *T) { // Clone the components. SmallVector<ComponentIdentTypeRepr*, 8> components; components.reserve(T->getComponents().size()); for (auto &component : T->getComponents()) { components.push_back(cast<ComponentIdentTypeRepr>(visit(component))); } return CompoundIdentTypeRepr::create(Ctx, components); }
BranchInst *SILBuilder::createBranch(SILLocation Loc, SILBasicBlock *TargetBlock, OperandValueArrayRef Args) { SmallVector<SILValue, 6> ArgsCopy; ArgsCopy.reserve(Args.size()); for (auto I = Args.begin(), E = Args.end(); I != E; ++I) ArgsCopy.push_back(*I); return createBranch(Loc, TargetBlock, ArgsCopy); }
/// InitializeSlots - Process all spill stack slot liveintervals and add them /// to a sorted (by weight) list. void StackSlotColoring::InitializeSlots() { int LastFI = MFI->getObjectIndexEnd(); // There is always at least one stack ID. AllColors.resize(1); UsedColors.resize(1); OrigAlignments.resize(LastFI); OrigSizes.resize(LastFI); AllColors[0].resize(LastFI); UsedColors[0].resize(LastFI); Assignments.resize(LastFI); using Pair = std::iterator_traits<LiveStacks::iterator>::value_type; SmallVector<Pair *, 16> Intervals; Intervals.reserve(LS->getNumIntervals()); for (auto &I : *LS) Intervals.push_back(&I); llvm::sort(Intervals.begin(), Intervals.end(), [](Pair *LHS, Pair *RHS) { return LHS->first < RHS->first; }); // Gather all spill slots into a list. LLVM_DEBUG(dbgs() << "Spill slot intervals:\n"); for (auto *I : Intervals) { LiveInterval &li = I->second; LLVM_DEBUG(li.dump()); int FI = TargetRegisterInfo::stackSlot2Index(li.reg); if (MFI->isDeadObjectIndex(FI)) continue; SSIntervals.push_back(&li); OrigAlignments[FI] = MFI->getObjectAlignment(FI); OrigSizes[FI] = MFI->getObjectSize(FI); auto StackID = MFI->getStackID(FI); if (StackID != 0) { AllColors.resize(StackID + 1); UsedColors.resize(StackID + 1); AllColors[StackID].resize(LastFI); UsedColors[StackID].resize(LastFI); } AllColors[StackID].set(FI); } LLVM_DEBUG(dbgs() << '\n'); // Sort them by weight. std::stable_sort(SSIntervals.begin(), SSIntervals.end(), IntervalSorter()); NextColors.resize(AllColors.size()); // Get first "color". for (unsigned I = 0, E = AllColors.size(); I != E; ++I) NextColors[I] = AllColors[I].find_first(); }
// Add an operand to an existing MDNode. The new operand will be added at the // back of the operand list. static void AddOperand(DICompileUnit *CU, DISubprogramArray SPs, Metadata *NewSP) { SmallVector<Metadata *, 16> NewSPs; NewSPs.reserve(SPs.size() + 1); for (auto *SP : SPs) NewSPs.push_back(SP); NewSPs.push_back(NewSP); CU->replaceSubprograms(MDTuple::get(CU->getContext(), NewSPs)); }
void DwarfCompileUnit::attachRangesOrLowHighPC( DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) { SmallVector<RangeSpan, 2> List; List.reserve(Ranges.size()); for (const InsnRange &R : Ranges) List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first), DD->getLabelAfterInsn(R.second))); attachRangesOrLowHighPC(Die, std::move(List)); }
ProtocolConformance *ProtocolConformance::subst(Module *module, Type substType, ArrayRef<Substitution> subs, TypeSubstitutionMap &subMap, ArchetypeConformanceMap &conformanceMap) { if (getType()->isEqual(substType)) return this; switch (getKind()) { case ProtocolConformanceKind::Normal: if (substType->isSpecialized()) { assert(getType()->isSpecialized() && "substitution mapped non-specialized to specialized?!"); assert(getType()->getNominalOrBoundGenericNominal() == substType->getNominalOrBoundGenericNominal() && "substitution mapped to different nominal?!"); return module->getASTContext() .getSpecializedConformance(substType, this, substType->gatherAllSubstitutions(module, nullptr)); } assert(substType->isEqual(getType()) && "substitution changed non-specialized type?!"); return this; case ProtocolConformanceKind::Inherited: { // Substitute the base. auto inheritedConformance = cast<InheritedProtocolConformance>(this)->getInheritedConformance(); ProtocolConformance *newBase; if (inheritedConformance->getType()->isSpecialized()) { newBase = inheritedConformance->subst(module, substType, subs, subMap, conformanceMap); } else { newBase = inheritedConformance; } return module->getASTContext() .getInheritedConformance(substType, newBase); } case ProtocolConformanceKind::Specialized: { // Substitute the substitutions in the specialized conformance. auto spec = cast<SpecializedProtocolConformance>(this); SmallVector<Substitution, 8> newSubs; newSubs.reserve(spec->getGenericSubstitutions().size()); for (auto &sub : spec->getGenericSubstitutions()) newSubs.push_back(sub.subst(module, subs, subMap, conformanceMap)); auto ctxNewSubs = module->getASTContext().AllocateCopy(newSubs); return module->getASTContext() .getSpecializedConformance(substType, spec->getGenericConformance(), ctxNewSubs); } } llvm_unreachable("bad ProtocolConformanceKind"); }
TypeRepr *CloneVisitor::visitGenericIdentTypeRepr(GenericIdentTypeRepr *T) { // Clone the generic arguments. SmallVector<TypeRepr*, 8> genericArgs; genericArgs.reserve(T->getGenericArgs().size()); for (auto &arg : T->getGenericArgs()) { genericArgs.push_back(visit(arg)); } return GenericIdentTypeRepr::create(Ctx, T->getIdLoc(), T->getIdentifier(), genericArgs, T->getAngleBrackets()); }
NamedMDNode *NamedMDNode::Create(const NamedMDNode *NMD, Module *M) { assert(NMD && "Invalid source NamedMDNode!"); SmallVector<MDNode *, 4> Elems; Elems.reserve(NMD->getNumOperands()); for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) Elems.push_back(NMD->getOperand(i)); return new NamedMDNode(NMD->getContext(), NMD->getName().data(), Elems.data(), Elems.size(), M); }
/// RemapInstruction - Convert the instruction operands from referencing the /// current values into those specified by VMap. /// void llvm::RemapInstruction(Instruction *I, ValueToValueMapTy &VMap, RemapFlags Flags, ValueMapTypeRemapper *TypeMapper, ValueMaterializer *Materializer){ // Remap operands. for (User::op_iterator op = I->op_begin(), E = I->op_end(); op != E; ++op) { Value *V = MapValue(*op, VMap, Flags, TypeMapper, Materializer); // If we aren't ignoring missing entries, assert that something happened. if (V) *op = V; else assert((Flags & RF_IgnoreMissingEntries) && "Referenced value not in value map!"); } // Remap phi nodes' incoming blocks. if (PHINode *PN = dyn_cast<PHINode>(I)) { for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { Value *V = MapValue(PN->getIncomingBlock(i), VMap, Flags); // If we aren't ignoring missing entries, assert that something happened. if (V) PN->setIncomingBlock(i, cast<BasicBlock>(V)); else assert((Flags & RF_IgnoreMissingEntries) && "Referenced block not in value map!"); } } // Remap attached metadata. SmallVector<std::pair<unsigned, MDNode *>, 4> MDs; I->getAllMetadata(MDs); for (SmallVectorImpl<std::pair<unsigned, MDNode *>>::iterator MI = MDs.begin(), ME = MDs.end(); MI != ME; ++MI) { MDNode *Old = MI->second; MDNode *New = MapMetadata(Old, VMap, Flags, TypeMapper, Materializer); if (New != Old) I->setMetadata(MI->first, New); } if (!TypeMapper) return; // If the instruction's type is being remapped, do so now. if (auto CS = CallSite(I)) { SmallVector<Type *, 3> Tys; FunctionType *FTy = CS.getFunctionType(); Tys.reserve(FTy->getNumParams()); for (Type *Ty : FTy->params()) Tys.push_back(TypeMapper->remapType(Ty)); CS.mutateFunctionType(FunctionType::get( TypeMapper->remapType(I->getType()), Tys, FTy->isVarArg())); } else I->mutateType(TypeMapper->remapType(I->getType())); }
LLVMContextImpl::~LLVMContextImpl() { std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(), DropReferences()); std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(), DropReferences()); std::for_each(StructConstants.map_begin(), StructConstants.map_end(), DropReferences()); std::for_each(UnionConstants.map_begin(), UnionConstants.map_end(), DropReferences()); std::for_each(VectorConstants.map_begin(), VectorConstants.map_end(), DropReferences()); ExprConstants.freeConstants(); ArrayConstants.freeConstants(); StructConstants.freeConstants(); UnionConstants.freeConstants(); VectorConstants.freeConstants(); AggZeroConstants.freeConstants(); NullPtrConstants.freeConstants(); UndefValueConstants.freeConstants(); InlineAsms.freeConstants(); for (IntMapTy::iterator I = IntConstants.begin(), E = IntConstants.end(); I != E; ++I) { delete I->second; } for (FPMapTy::iterator I = FPConstants.begin(), E = FPConstants.end(); I != E; ++I) { delete I->second; } AlwaysOpaqueTy->dropRef(); for (OpaqueTypesTy::iterator I = OpaqueTypes.begin(), E = OpaqueTypes.end(); I != E; ++I) { (*I)->AbstractTypeUsers.clear(); delete *I; } // Destroy MDNodes. ~MDNode can move and remove nodes between the MDNodeSet // and the NonUniquedMDNodes sets, so copy the values out first. SmallVector<MDNode*, 8> MDNodes; MDNodes.reserve(MDNodeSet.size() + NonUniquedMDNodes.size()); for (FoldingSetIterator<MDNode> I = MDNodeSet.begin(), E = MDNodeSet.end(); I != E; ++I) { MDNodes.push_back(&*I); } MDNodes.append(NonUniquedMDNodes.begin(), NonUniquedMDNodes.end()); for (SmallVector<MDNode*, 8>::iterator I = MDNodes.begin(), E = MDNodes.end(); I != E; ++I) { (*I)->destroy(); } assert(MDNodeSet.empty() && NonUniquedMDNodes.empty() && "Destroying all MDNodes didn't empty the Context's sets."); // Destroy MDStrings. for (StringMap<MDString*>::iterator I = MDStringCache.begin(), E = MDStringCache.end(); I != E; ++I) { delete I->second; } }
TypeRepr *CloneVisitor::visitCompositionTypeRepr(CompositionTypeRepr *T) { // Clone the protocols. SmallVector<TypeRepr*, 8> types; types.reserve(T->getTypes().size()); for (auto &type : T->getTypes()) { types.push_back(cast<TypeRepr>(visit(type))); } return CompositionTypeRepr::create(Ctx, types, T->getStartLoc(), T->getCompositionRange()); }
TypeRepr *CloneVisitor::visitTupleTypeRepr(TupleTypeRepr *T) { // FIXME: Avoid this stash vector. SmallVector<TypeRepr *, 8> elements; elements.reserve(T->getNumElements()); for (auto *arg : T->getElements()) elements.push_back(visit(arg)); return TupleTypeRepr::create(Ctx, elements, T->getParens(), T->getElementNames(), T->getElementNameLocs(), T->getUnderscoreLocs(), T->getEllipsisLoc(), T->getEllipsisIndex()); }
TypeRepr *CloneVisitor::visitTupleTypeRepr(TupleTypeRepr *T) { SmallVector<TupleTypeReprElement, 8> elements; elements.reserve(T->getNumElements()); for (auto arg : T->getElements()) { arg.Type = visit(arg.Type); elements.push_back(arg); } return TupleTypeRepr::create(Ctx, elements, T->getParens(), T->getEllipsisLoc(), T->getEllipsisIndex()); }
void DICompositeType::addMember(DIDescriptor D) { SmallVector<llvm::Value *, 16> M; DIArray OrigM = getTypeArray(); unsigned Elements = OrigM.getNumElements(); if (Elements == 1 && !OrigM.getElement(0)) Elements = 0; M.reserve(Elements + 1); for (unsigned i = 0; i != Elements; ++i) M.push_back(OrigM.getElement(i)); M.push_back(D); setTypeArray(DIArray(MDNode::get(DbgNode->getContext(), M))); }
// Propagate existing explicit probabilities from either profile data or // 'expect' intrinsic processing. bool BranchProbabilityInfo::calcMetadataWeights(BasicBlock *BB) { TerminatorInst *TI = BB->getTerminator(); if (TI->getNumSuccessors() == 1) return false; if (!isa<BranchInst>(TI) && !isa<SwitchInst>(TI)) return false; MDNode *WeightsNode = TI->getMetadata(LLVMContext::MD_prof); if (!WeightsNode) return false; // Check that the number of successors is manageable. assert(TI->getNumSuccessors() < UINT32_MAX && "Too many successors"); // Ensure there are weights for all of the successors. Note that the first // operand to the metadata node is a name, not a weight. if (WeightsNode->getNumOperands() != TI->getNumSuccessors() + 1) return false; // Build up the final weights that will be used in a temporary buffer. // Compute the sum of all weights to later decide whether they need to // be scaled to fit in 32 bits. uint64_t WeightSum = 0; SmallVector<uint32_t, 2> Weights; Weights.reserve(TI->getNumSuccessors()); for (unsigned i = 1, e = WeightsNode->getNumOperands(); i != e; ++i) { ConstantInt *Weight = mdconst::dyn_extract<ConstantInt>(WeightsNode->getOperand(i)); if (!Weight) return false; assert(Weight->getValue().getActiveBits() <= 32 && "Too many bits for uint32_t"); Weights.push_back(Weight->getZExtValue()); WeightSum += Weights.back(); } assert(Weights.size() == TI->getNumSuccessors() && "Checked above"); // If the sum of weights does not fit in 32 bits, scale every weight down // accordingly. uint64_t ScalingFactor = (WeightSum > UINT32_MAX) ? WeightSum / UINT32_MAX + 1 : 1; WeightSum = 0; for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i) { uint32_t W = Weights[i] / ScalingFactor; WeightSum += W; setEdgeWeight(BB, i, W); } assert(WeightSum <= UINT32_MAX && "Expected weights to scale down to 32 bits"); return true; }
/// splitInsideBlock - Split curli into multiple intervals inside MBB. Return /// true if curli has been completely replaced, false if curli is still /// intact, and needs to be spilled or split further. bool SplitEditor::splitInsideBlock(const MachineBasicBlock *MBB) { SmallVector<SlotIndex, 32> Uses; Uses.reserve(sa_.usingInstrs_.size()); for (SplitAnalysis::InstrPtrSet::const_iterator I = sa_.usingInstrs_.begin(), E = sa_.usingInstrs_.end(); I != E; ++I) if ((*I)->getParent() == MBB) Uses.push_back(lis_.getInstructionIndex(*I)); DEBUG(dbgs() << " splitInsideBlock BB#" << MBB->getNumber() << " for " << Uses.size() << " instructions.\n"); assert(Uses.size() >= 3 && "Need at least 3 instructions"); array_pod_sort(Uses.begin(), Uses.end()); // Simple algorithm: Find the largest gap between uses as determined by slot // indices. Create new intervals for instructions before the gap and after the // gap. unsigned bestPos = 0; int bestGap = 0; DEBUG(dbgs() << " dist (" << Uses[0]); for (unsigned i = 1, e = Uses.size(); i != e; ++i) { int g = Uses[i-1].distance(Uses[i]); DEBUG(dbgs() << ") -" << g << "- (" << Uses[i]); if (g > bestGap) bestPos = i, bestGap = g; } DEBUG(dbgs() << "), best: -" << bestGap << "-\n"); // bestPos points to the first use after the best gap. assert(bestPos > 0 && "Invalid gap"); // FIXME: Don't create intervals for low densities. // First interval before the gap. Don't create single-instr intervals. if (bestPos > 1) { openIntv(); enterIntvBefore(Uses.front()); useIntv(Uses.front().getBaseIndex(), Uses[bestPos-1].getBoundaryIndex()); leaveIntvAfter(Uses[bestPos-1]); closeIntv(); } // Second interval after the gap. if (bestPos < Uses.size()-1) { openIntv(); enterIntvBefore(Uses[bestPos]); useIntv(Uses[bestPos].getBaseIndex(), Uses.back().getBoundaryIndex()); leaveIntvAfter(Uses.back()); closeIntv(); } rewrite(); return dupli_; }
llvm::MDNode * CodeGenPGO::createBranchWeights(ArrayRef<uint64_t> Weights) { llvm::MDBuilder MDHelper(CGM.getLLVMContext()); // TODO: need to scale down to 32-bits, instead of just truncating. // According to Laplace's Rule of Succession, it is better to compute the // weight based on the count plus 1. SmallVector<uint32_t, 16> ScaledWeights; ScaledWeights.reserve(Weights.size()); for (ArrayRef<uint64_t>::iterator WI = Weights.begin(), WE = Weights.end(); WI != WE; ++WI) { ScaledWeights.push_back(*WI + 1); } return MDHelper.createBranchWeights(ScaledWeights); }
int main(int argc, const char *argv[]) { unsigned numForwardedArgs = argc - 1 // we drop argv[0] + 1; // -interpret SmallVector<const char *, 8> forwardedArgs; forwardedArgs.reserve(numForwardedArgs); forwardedArgs.append(&argv[1], &argv[argc]); forwardedArgs.push_back("-interpret"); assert(forwardedArgs.size() == numForwardedArgs); Observer observer; return performFrontend(forwardedArgs, argv[0], (void*) &printMetadataType, &observer); }
/// WriteBitcodeToFile - Write the specified module to the specified output /// stream. void llvm::NaClWriteBitcodeToFile(const Module *M, raw_ostream &Out, bool AcceptSupportedOnly) { SmallVector<char, 0> Buffer; Buffer.reserve(256*1024); // Emit the module into the buffer. { NaClBitstreamWriter Stream(Buffer); NaClWriteHeader(Stream, AcceptSupportedOnly); WriteModule(M, Stream); } // Write the generated bitstream to "Out". Out.write((char*)&Buffer.front(), Buffer.size()); }