void HeaderSearch::collectAllModules(llvm::SmallVectorImpl<Module *> &Modules) {
Modules.clear();
// Load module maps for each of the header search directories.
for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
if (SearchDirs[Idx].isFramework()) {
llvm::error_code EC;
SmallString<128> DirNative;
llvm::sys::path::native(SearchDirs[Idx].getFrameworkDir()->getName(),
DirNative);
// Search each of the ".framework" directories to load them as modules.
bool IsSystem = SearchDirs[Idx].getDirCharacteristic() != SrcMgr::C_User;
for (llvm::sys::fs::directory_iterator Dir(DirNative.str(), EC), DirEnd;
Dir != DirEnd && !EC; Dir.increment(EC)) {
if (llvm::sys::path::extension(Dir->path()) != ".framework")
continue;
const DirectoryEntry *FrameworkDir = FileMgr.getDirectory(Dir->path());
if (!FrameworkDir)
continue;
// Load this framework module.
loadFrameworkModule(llvm::sys::path::stem(Dir->path()), FrameworkDir,
IsSystem);
}
continue;
}
// FIXME: Deal with header maps.
if (SearchDirs[Idx].isHeaderMap())
continue;
// Try to load a module map file for the search directory.
loadModuleMapFile(SearchDirs[Idx].getDir());
// Try to load module map files for immediate subdirectories of this search
// directory.
llvm::error_code EC;
SmallString<128> DirNative;
llvm::sys::path::native(SearchDirs[Idx].getDir()->getName(), DirNative);
for (llvm::sys::fs::directory_iterator Dir(DirNative.str(), EC), DirEnd;
Dir != DirEnd && !EC; Dir.increment(EC)) {
loadModuleMapFile(Dir->path());
}
}
// Populate the list of modules.
for (ModuleMap::module_iterator M = ModMap.module_begin(),
MEnd = ModMap.module_end();
M != MEnd; ++M) {
Modules.push_back(M->getValue());
}
}
static SILValue allIncomingValuesEqual(
llvm::SmallVectorImpl<std::pair<SILBasicBlock *,
SILValue >> &IncomingValues) {
SILValue First = stripRCIdentityPreservingInsts(IncomingValues[0].second);
if (std::all_of(std::next(IncomingValues.begin()), IncomingValues.end(),
[&First](std::pair<SILBasicBlock *, SILValue> P) -> bool {
return stripRCIdentityPreservingInsts(P.second) == First;
}))
return First;
return SILValue();
}
void
HostThreadLinux::GetName(lldb::thread_t thread, llvm::SmallVectorImpl<char> &name)
{
// Read /proc/$TID/comm file.
lldb::DataBufferSP buf_sp = process_linux::ProcFileReader::ReadIntoDataBuffer(thread, "comm");
const char *comm_str = (const char *)buf_sp->GetBytes();
const char *cr_str = ::strchr(comm_str, '\n');
size_t length = cr_str ? (cr_str - comm_str) : strlen(comm_str);
name.clear();
name.append(comm_str, comm_str + length);
}
// This routine takes in the ARCMatchingSet \p MatchSet and inserts new
// increments, decrements at the insertion points and adds the old increment,
// decrements to the delete list. Sets changed to true if anything was moved or
// deleted.
void ARCPairingContext::optimizeMatchingSet(
ARCMatchingSet &MatchSet, llvm::SmallVectorImpl<SILInstruction *> &NewInsts,
llvm::SmallVectorImpl<SILInstruction *> &DeadInsts) {
DEBUG(llvm::dbgs() << "**** Optimizing Matching Set ****\n");
// Insert the new increments.
for (SILInstruction *InsertPt : MatchSet.IncrementInsertPts) {
if (!InsertPt) {
DEBUG(llvm::dbgs() << " No insertion point, not inserting increment "
"into new position.\n");
continue;
}
MadeChange = true;
SILInstruction *NewIncrement = createIncrement(MatchSet.Ptr, InsertPt);
NewInsts.push_back(NewIncrement);
DEBUG(llvm::dbgs() << " Inserting new increment: " << *NewIncrement
<< " At insertion point: " << *InsertPt);
++NumRefCountOpsMoved;
}
// Insert the new decrements.
for (SILInstruction *InsertPt : MatchSet.DecrementInsertPts) {
if (!InsertPt) {
DEBUG(llvm::dbgs() << " No insertion point, not inserting decrement "
"into its new position.\n");
continue;
}
MadeChange = true;
SILInstruction *NewDecrement = createDecrement(MatchSet.Ptr, InsertPt);
NewInsts.push_back(NewDecrement);
DEBUG(llvm::dbgs() << " Inserting new NewDecrement: " << *NewDecrement
<< " At insertion point: " << *InsertPt);
++NumRefCountOpsMoved;
}
// Add the old increments to the delete list.
for (SILInstruction *Increment : MatchSet.Increments) {
MadeChange = true;
DEBUG(llvm::dbgs() << " Deleting increment: " << *Increment);
DeadInsts.push_back(Increment);
++NumRefCountOpsRemoved;
}
// Add the old decrements to the delete list.
for (SILInstruction *Decrement : MatchSet.Decrements) {
MadeChange = true;
DEBUG(llvm::dbgs() << " Deleting decrement: " << *Decrement);
DeadInsts.push_back(Decrement);
++NumRefCountOpsRemoved;
}
}
/// \brief Find the end of the word starting at the given offset
/// within a string.
///
/// \returns the index pointing one character past the end of the
/// word.
static unsigned findEndOfWord(unsigned Start,
const llvm::SmallVectorImpl<char> &Str,
unsigned Length, unsigned Column,
unsigned Columns) {
assert(Start < Str.size() && "Invalid start position!");
unsigned End = Start + 1;
// If we are already at the end of the string, take that as the word.
if (End == Str.size())
return End;
// Determine if the start of the string is actually opening
// punctuation, e.g., a quote or parentheses.
char EndPunct = findMatchingPunctuation(Str[Start]);
if (!EndPunct) {
// This is a normal word. Just find the first space character.
while (End < Length && !isspace(Str[End]))
++End;
return End;
}
// We have the start of a balanced punctuation sequence (quotes,
// parentheses, etc.). Determine the full sequence is.
llvm::SmallVector<char, 16> PunctuationEndStack;
PunctuationEndStack.push_back(EndPunct);
while (End < Length && !PunctuationEndStack.empty()) {
if (Str[End] == PunctuationEndStack.back())
PunctuationEndStack.pop_back();
else if (char SubEndPunct = findMatchingPunctuation(Str[End]))
PunctuationEndStack.push_back(SubEndPunct);
++End;
}
// Find the first space character after the punctuation ended.
while (End < Length && !isspace(Str[End]))
++End;
unsigned PunctWordLength = End - Start;
if (// If the word fits on this line
Column + PunctWordLength <= Columns ||
// ... or the word is "short enough" to take up the next line
// without too much ugly white space
PunctWordLength < Columns/3)
return End; // Take the whole thing as a single "word".
// The whole quoted/parenthesized string is too long to print as a
// single "word". Instead, find the "word" that starts just after
// the punctuation and use that end-point instead. This will recurse
// until it finds something small enough to consider a word.
return findEndOfWord(Start + 1, Str, Length, Column + 1, Columns);
}
void ClassTemplateDecl::getPartialSpecializations(
llvm::SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) {
llvm::FoldingSet<ClassTemplatePartialSpecializationDecl> &PartialSpecs
= getPartialSpecializations();
PS.clear();
PS.resize(PartialSpecs.size());
for (llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator
P = PartialSpecs.begin(), PEnd = PartialSpecs.end();
P != PEnd; ++P) {
assert(!PS[P->getSequenceNumber()]);
PS[P->getSequenceNumber()] = P->getMostRecentDeclaration();
}
}
llvm::ArrayRef<CS_Sink> EnumerateSourceSinks(
CS_Source source, llvm::SmallVectorImpl<CS_Sink>& vec, CS_Status* status) {
auto data = Sources::GetInstance().Get(source);
if (!data) {
*status = CS_INVALID_HANDLE;
return llvm::ArrayRef<CS_Sink>{};
}
vec.clear();
Sinks::GetInstance().ForEach([&](CS_Sink sinkHandle, const SinkData& data) {
if (source == data.sourceHandle.load()) vec.push_back(sinkHandle);
});
return vec;
}
// Devirtualize and specialize a group of applies, returning a
// worklist of newly exposed function references that should be
// considered for inlining before continuing with the caller that has
// the passed-in applies.
//
// The returned worklist is stacked such that the last things we want
// to process are earlier on the list.
//
// Returns true if any changes were made.
bool SILPerformanceInliner::devirtualizeAndSpecializeApplies(
llvm::SmallVectorImpl<ApplySite> &Applies,
SILModuleTransform *MT,
ClassHierarchyAnalysis *CHA,
llvm::SmallVectorImpl<SILFunction *> &WorkList) {
assert(WorkList.empty() && "Expected empty worklist for return results!");
bool ChangedAny = false;
// The set of all new function references generated by
// devirtualization and specialization.
llvm::SetVector<SILFunction *> NewRefs;
// Process all applies passed in, plus any new ones that are pushed
// on as a result of specializing the referenced functions.
while (!Applies.empty()) {
auto Apply = Applies.back();
Applies.pop_back();
bool ChangedApply = false;
if (auto FullApply = FullApplySite::isa(Apply.getInstruction())) {
if (auto NewApply = devirtualize(FullApply, CHA)) {
ChangedApply = true;
Apply = ApplySite(NewApply.getInstruction());
}
}
llvm::SmallVector<ApplySite, 4> NewApplies;
if (auto NewApply = specializeGeneric(Apply, NewApplies)) {
ChangedApply = true;
Apply = NewApply;
Applies.insert(Applies.end(), NewApplies.begin(), NewApplies.end());
}
if (ChangedApply) {
ChangedAny = true;
auto *NewCallee = Apply.getCalleeFunction();
assert(NewCallee && "Expected directly referenced function!");
// Track all new references to function definitions.
if (NewCallee->isDefinition())
NewRefs.insert(NewCallee);
// TODO: Do we need to invalidate everything at this point?
// What about side-effects analysis? What about type analysis?
MT->invalidateAnalysis(Apply.getFunction(),
SILAnalysis::InvalidationKind::Everything);
}
}
// Copy out all the new function references gathered.
if (ChangedAny)
WorkList.insert(WorkList.end(), NewRefs.begin(), NewRefs.end());
return ChangedAny;
}
void SILValueOwnershipChecker::gatherUsers(
llvm::SmallVectorImpl<SILInstruction *> &LifetimeEndingUsers,
llvm::SmallVectorImpl<SILInstruction *> &NonLifetimeEndingUsers) {
for (Operand *Op : Value->getUses()) {
auto *User = Op->getUser();
if (OwnershipCompatibilityUseChecker(Mod, *Op).check(User)) {
DEBUG(llvm::dbgs() << " Lifetime Ending User: "******" Regular User: " << *User);
NonLifetimeEndingUsers.push_back(User);
}
}
}
llvm::error_code canonicalize(const llvm::Twine &path, llvm::SmallVectorImpl<char> &result) {
std::string p = path.str();
#ifdef PATH_MAX
int path_max = PATH_MAX;
#else
int path_max = pathconf(p.c_str(), _PC_PATH_MAX);
if (path_max <= 0)
path_max = 4096;
#endif
result.resize(path_max);
realpath(p.c_str(), result.data());
result.resize(strlen(result.data()));
return llvm::error_code::success();
}
/// getSpelling - This method is used to get the spelling of a token into a
/// SmallVector. Note that the returned StringRef may not point to the
/// supplied buffer if a copy can be avoided.
llvm::StringRef Preprocessor::getSpelling(const Token &Tok,
llvm::SmallVectorImpl<char> &Buffer,
bool *Invalid) const {
// Try the fast path.
if (const IdentifierInfo *II = Tok.getIdentifierInfo())
return II->getName();
// Resize the buffer if we need to copy into it.
if (Tok.needsCleaning())
Buffer.resize(Tok.getLength());
const char *Ptr = Buffer.data();
unsigned Len = getSpelling(Tok, Ptr, Invalid);
return llvm::StringRef(Ptr, Len);
}
static void findNominalsAndOperators(
llvm::MapVector<const NominalTypeDecl *, bool> &foundNominals,
llvm::SmallVectorImpl<const FuncDecl *> &foundOperators,
DeclRange members) {
for (const Decl *D : members) {
auto *VD = dyn_cast<ValueDecl>(D);
if (!VD)
continue;
if (VD->hasAccessibility() &&
VD->getFormalAccess() <= Accessibility::FilePrivate) {
continue;
}
if (VD->getFullName().isOperator()) {
foundOperators.push_back(cast<FuncDecl>(VD));
continue;
}
auto nominal = dyn_cast<NominalTypeDecl>(D);
if (!nominal)
continue;
foundNominals[nominal] |= true;
findNominalsAndOperators(foundNominals, foundOperators,
nominal->getMembers());
}
}
void
PMDescriptor::
descriptorsForFile(StringRef Filename,
llvm::SmallVectorImpl<PMDescriptor> &Descriptors) {
namespace yaml = llvm::yaml;
// Load the input file.
llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> FileBufOrErr =
llvm::MemoryBuffer::getFileOrSTDIN(Filename);
if (!FileBufOrErr) {
llvm_unreachable("Failed to read yaml file");
}
StringRef Buffer = FileBufOrErr->get()->getBuffer();
llvm::SourceMgr SM;
yaml::Stream Stream(Buffer, SM);
yaml::document_iterator DI = Stream.begin();
assert(DI != Stream.end() && "Failed to read a document");
yaml::Node *N = DI->getRoot();
assert(N && "Failed to find a root");
auto *RootList = cast<yaml::SequenceNode>(N);
for (auto &PMDescriptorIter : make_range(RootList->begin(), RootList->end())) {
PMDescriptor PM(cast<yaml::SequenceNode>(&PMDescriptorIter));
Descriptors.push_back(std::move(PM));
}
}
void
DeclContext::collectAllContexts(llvm::SmallVectorImpl<DeclContext *> &Contexts){
Contexts.clear();
if (DeclKind != Decl::Namespace) {
Contexts.push_back(this);
return;
}
NamespaceDecl *Self = static_cast<NamespaceDecl *>(this);
for (NamespaceDecl *N = Self->getMostRecentDecl(); N;
N = N->getPreviousDecl())
Contexts.push_back(N);
std::reverse(Contexts.begin(), Contexts.end());
}
void swiftcall::legalizeVectorType(CodeGenModule &CGM, CharUnits origVectorSize,
llvm::VectorType *origVectorTy,
llvm::SmallVectorImpl<llvm::Type*> &components) {
// If it's already a legal vector type, use it.
if (isLegalVectorType(CGM, origVectorSize, origVectorTy)) {
components.push_back(origVectorTy);
return;
}
// Try to split the vector into legal subvectors.
auto numElts = origVectorTy->getNumElements();
auto eltTy = origVectorTy->getElementType();
assert(numElts != 1);
// The largest size that we're still considering making subvectors of.
// Always a power of 2.
unsigned logCandidateNumElts = llvm::findLastSet(numElts, llvm::ZB_Undefined);
unsigned candidateNumElts = 1U << logCandidateNumElts;
assert(candidateNumElts <= numElts && candidateNumElts * 2 > numElts);
// Minor optimization: don't check the legality of this exact size twice.
if (candidateNumElts == numElts) {
logCandidateNumElts--;
candidateNumElts >>= 1;
}
// TODO: This should really be an operation on type lowering.
void SILBuilder::emitShallowDestructureValueOperation(
SILLocation Loc, SILValue V, llvm::SmallVectorImpl<SILValue> &Results) {
// Once destructure is allowed everywhere, remove the projection code.
// If we do not have a tuple or a struct, add to our results list and return.
SILType Ty = V->getType();
if (!(Ty.is<TupleType>() || Ty.getStructOrBoundGenericStruct())) {
Results.emplace_back(V);
return;
}
// Otherwise, we want to destructure add the destructure and return.
if (getFunction().hasQualifiedOwnership()) {
auto *DI = emitDestructureValueOperation(Loc, V);
copy(DI->getResults(), std::back_inserter(Results));
return;
}
// In non qualified ownership SIL, drop back to using projection code.
llvm::SmallVector<Projection, 16> Projections;
Projection::getFirstLevelProjections(V->getType(), getModule(), Projections);
transform(Projections, std::back_inserter(Results),
[&](const Projection &P) -> SILValue {
return P.createObjectProjection(*this, Loc, V).get();
});
}
// Since we have an RValue, we know that RValue invariants imply that all
// subvalues that are addresses must be address only types. Such address only
// types if they are +1 rvalues should be independent of any values from outside
// the +1 rvalue emission (that is if someone else has a reference to the
// address only type, we should have produced a copy). This means that it is
// safe to move the value into new memory that is guaranteed to live through the
// scope being pushed. As an additional complication due to SIL enforcing stack
// ordering, we can not use a temporary stack location since any stack locations
// that are inside the scope will be cleaned up while such a scope jumping stack
// is still alive (violating stack ordering). Instead we use an alloc_box to
// store the new value. allocbox-to-stack will then reorder/expand the stack
// lifetimes to resolve the issues.
static void lifetimeExtendAddressOnlyRValueSubValues(
SILGenFunction &SGF, SILLocation loc,
llvm::SmallVectorImpl<SILValue> &values,
llvm::SmallVectorImpl<SILValue> &lifetimeExtendingBoxes) {
for (SILValue &v : values) {
// If v is not an address, it isn't interesting, continue.
if (!v->getType().isAddress()) {
continue;
}
// Otherwise, create the box and move the address only value into the box.
assert(v->getType().isAddressOnly(SGF.getModule()) &&
"RValue invariants imply that all RValue subtypes that are "
"addresses must be address only.");
auto boxTy = SILBoxType::get(v->getType().getSwiftRValueType());
SILValue box = SGF.B.createAllocBox(loc, boxTy);
SILValue addr = SGF.B.createProjectBox(loc, box, 0);
SGF.B.createCopyAddr(loc, v, addr, IsTake, IsInitialization);
// Then save the box so we create the box destroy in the caller and
// overwrite v with the project box since that is where the value is now.
lifetimeExtendingBoxes.emplace_back(box);
v = addr;
}
}
// Find the relevant insertion points for the loop region R in its
// successors. Returns true if we succeeded. Returns false if any of the
// non-local successors of the region are not leaking blocks. We currently do
// not handle early exits, but do handle trapping blocks.
static bool getInsertionPtsForLoopRegionExits(
const LoopRegion *R, LoopRegionFunctionInfo *LRFI,
llvm::DenseMap<const LoopRegion *, ARCRegionState *> &RegionStateInfo,
llvm::SmallVectorImpl<SILInstruction *> &InsertPts) {
assert(R->isLoop() && "Expected a loop region that is representing a loop");
// Go through all of our non local successors. If any of them can not be
// ignored, we bail for simplicity. This means that for now we do not handle
// early exits.
if (any_of(R->getNonLocalSuccs(), [&](unsigned SuccID) -> bool {
return !RegionStateInfo[LRFI->getRegion(SuccID)]->allowsLeaks();
})) {
return false;
}
// We assume that all of our loops have been canonicalized so that /all/ loop
// exit blocks only have exiting blocks as predecessors. This means that all
// successor regions of any region /cannot/ be a region representing a loop.
for (unsigned SuccID : R->getLocalSuccs()) {
auto *SuccRegion = LRFI->getRegion(SuccID);
assert(SuccRegion->isBlock() && "Loop canonicalization failed?!");
InsertPts.push_back(&*SuccRegion->getBlock()->begin());
}
return true;
}
ApplySite SILPerformanceInliner::specializeGeneric(
ApplySite Apply, llvm::SmallVectorImpl<ApplySite> &NewApplies) {
assert(NewApplies.empty() && "Expected out parameter for new applies!");
if (!Apply.hasSubstitutions())
return ApplySite();
auto *Callee = Apply.getCalleeFunction();
if (!Callee || Callee->isExternalDeclaration())
return ApplySite();
auto Filter = [](SILInstruction *I) -> bool {
return ApplySite::isa(I) != ApplySite();
};
CloneCollector Collector(Filter);
SILFunction *SpecializedFunction;
auto Specialized = trySpecializeApplyOfGeneric(Apply,
SpecializedFunction,
Collector);
if (!Specialized)
return ApplySite();
// Track the new applies from the specialization.
for (auto NewCallSite : Collector.getInstructionPairs())
NewApplies.push_back(ApplySite(NewCallSite.first));
auto FullApply = FullApplySite::isa(Apply.getInstruction());
if (!FullApply) {
assert(!FullApplySite::isa(Specialized.getInstruction()) &&
"Unexpected full apply generated!");
// Replace the old apply with the new and delete the old.
replaceDeadApply(Apply, Specialized.getInstruction());
return ApplySite(Specialized);
}
// Replace the old apply with the new and delete the old.
replaceDeadApply(Apply, Specialized.getInstruction());
return Specialized;
}
void
ThisThread::GetName(llvm::SmallVectorImpl<char> &name)
{
// Getting the thread name is not supported on Windows.
// TODO(zturner): In SetName(), make a TLS entry that contains the thread's name, and in this function
// try to extract that TLS entry.
name.clear();
}
/// ParseExpressionList - Used for argument-expression-list.
///
/// argument-expression-list:
/// assignment-expression
/// argument-expression-list , assignment-expression
///
bool Parser::ParseExpressionList(llvm::SmallVectorImpl<Expr*> &Exprs,
llvm::SmallVectorImpl<SourceLocation> &CommaLocs) {
while (1) {
ExprResult Var;
ExprResult Expr(ParseAssignmentExpression(Var));
if (Expr.isInvalid())
return true;
Exprs.push_back(Expr.release());
if (Tok.isNot(tok::Comma))
return false;
// Move to the next argument, remember where the comma was.
CommaLocs.push_back(ConsumeToken());
}
}
void
Builtin::Context::GetBuiltinNames(llvm::SmallVectorImpl<const char *> &Names,
bool NoBuiltins) {
// Final all target-independent names
for (unsigned i = Builtin::NotBuiltin+1; i != Builtin::FirstTSBuiltin; ++i)
if (!BuiltinInfo[i].Suppressed &&
(!NoBuiltins || !strchr(BuiltinInfo[i].Attributes, 'f')))
Names.push_back(BuiltinInfo[i].Name);
// Find target-specific names.
for (unsigned i = 0, e = NumTSRecords; i != e; ++i)
if (!TSRecords[i].Suppressed &&
(!NoBuiltins ||
(TSRecords[i].Attributes &&
!strchr(TSRecords[i].Attributes, 'f'))))
Names.push_back(TSRecords[i].Name);
}
// FIXME: Why don't we just put this list in the defs file, eh.
void types::getCompilationPhases(ID Id, llvm::SmallVectorImpl<phases::ID> &P) {
if (Id != TY_Object) {
if (getPreprocessedType(Id) != TY_INVALID) {
P.push_back(phases::Preprocess);
}
if (onlyPrecompileType(Id)) {
P.push_back(phases::Precompile);
} else {
if (!onlyAssembleType(Id)) {
P.push_back(phases::Compile);
P.push_back(phases::Backend);
}
if (Id != TY_CUDA_DEVICE)
P.push_back(phases::Assemble);
}
}
if (!onlyPrecompileType(Id) && Id != TY_CUDA_DEVICE) {
P.push_back(phases::Link);
}
assert(0 < P.size() && "Not enough phases in list");
assert(P.size() <= phases::MaxNumberOfPhases && "Too many phases in list");
return;
}
void
NSErrorChecker::CheckSignature(const FunctionDecl& F, QualType& ResultTy,
llvm::SmallVectorImpl<VarDecl*>& ErrorParams) {
ResultTy = F.getResultType();
for (FunctionDecl::param_const_iterator I = F.param_begin(),
E = F.param_end(); I != E; ++I) {
QualType T = (*I)->getType();
if (isNSErrorWarning) {
if (CheckNSErrorArgument(T)) ErrorParams.push_back(*I);
}
else if (CheckCFErrorArgument(T))
ErrorParams.push_back(*I);
}
}
static void appendCodePoint(unsigned Codepoint,
llvm::SmallVectorImpl<char> &Str) {
char ResultBuf[4];
char *ResultPtr = ResultBuf;
bool Res = llvm::ConvertCodePointToUTF8(Codepoint, ResultPtr);
(void)Res;
assert(Res && "Unexpected conversion failure");
Str.append(ResultBuf, ResultPtr);
}
/// \brief Find all references to \p ParamDecl across all of the
/// redeclarations of \p Ctor.
static void
collectParamDecls(const CXXConstructorDecl *Ctor, const ParmVarDecl *ParamDecl,
llvm::SmallVectorImpl<const ParmVarDecl *> &Results) {
unsigned ParamIdx = ParamDecl->getFunctionScopeIndex();
for (CXXConstructorDecl::redecl_iterator I = Ctor->redecls_begin(),
E = Ctor->redecls_end();
I != E; ++I)
Results.push_back((*I)->getParamDecl(ParamIdx));
}
bool RequestDict::getUIDArray(SourceKit::UIdent Key,
llvm::SmallVectorImpl<sourcekitd_uid_t> &Arr,
bool isOptional) {
auto Object = static_cast<SKDObject *>(Dict)->get(SKDUIDFromUIdent(Key));
if (!Object)
return !isOptional;
auto Array = dyn_cast<SKDArray>(Object);
if (!Array)
return true;
size_t count = Array->getCount();
Arr.reserve(count);
for (size_t i = 0; i != count; ++i) {
auto UID = Array->get(i)->getUID();
if (!UID)
return true;
Arr.push_back(UID);
}
return false;
}
void FileManager::GetUniqueIDMapping(
llvm::SmallVectorImpl<const FileEntry *> &UIDToFiles) const {
UIDToFiles.clear();
UIDToFiles.resize(NextFileUID);
// Map file entries
for (llvm::StringMap<FileEntry*, llvm::BumpPtrAllocator>::const_iterator
FE = FileEntries.begin(), FEEnd = FileEntries.end();
FE != FEEnd; ++FE)
if (FE->getValue() && FE->getValue() != NON_EXISTENT_FILE)
UIDToFiles[FE->getValue()->getUID()] = FE->getValue();
// Map virtual file entries
for (llvm::SmallVector<FileEntry*, 4>::const_iterator
VFE = VirtualFileEntries.begin(), VFEEnd = VirtualFileEntries.end();
VFE != VFEEnd; ++VFE)
if (*VFE && *VFE != NON_EXISTENT_FILE)
UIDToFiles[(*VFE)->getUID()] = *VFE;
}
static unsigned
rewritePromotedBoxes(llvm::SmallVectorImpl<AllocBoxInst *> &Promoted,
llvm::SmallVectorImpl<Operand *> &PromotedOperands,
bool &CFGChanged) {
// First we'll rewrite any partial applies that we can to remove the
// box container pointer from the operands.
rewritePartialApplies(PromotedOperands, CFGChanged);
unsigned Count = 0;
auto rend = Promoted.rend();
for (auto I = Promoted.rbegin(); I != rend; ++I) {
auto *ABI = *I;
if (rewriteAllocBoxAsAllocStack(ABI)) {
++Count;
ABI->eraseFromParent();
}
}
return Count;
}
bool RequestDict::getStringArray(SourceKit::UIdent Key,
llvm::SmallVectorImpl<const char *> &Arr,
bool isOptional) {
auto Object = static_cast<SKDObject *>(Dict)->get(SKDUIDFromUIdent(Key));
if (!Object)
return !isOptional;
auto Array = dyn_cast<SKDArray>(Object);
if (!Array)
return true;
size_t count = Array->getCount();
Arr.reserve(count);
for (size_t i = 0; i != count; ++i) {
auto Str = Array->get(i)->getCString();
if (!Str)
return true;
Arr.push_back(Str);
}
return false;
}