static std::error_code
openModuleFiles(StringRef DirName, StringRef ModuleFilename,
StringRef ModuleDocFilename,
std::unique_ptr<llvm::MemoryBuffer> &ModuleBuffer,
std::unique_ptr<llvm::MemoryBuffer> &ModuleDocBuffer,
llvm::SmallVectorImpl<char> &Scratch) {
// Try to open the module file first. If we fail, don't even look for the
// module documentation file.
Scratch.clear();
llvm::sys::path::append(Scratch, DirName, ModuleFilename);
llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ModuleOrErr =
llvm::MemoryBuffer::getFile(StringRef(Scratch.data(), Scratch.size()));
if (!ModuleOrErr)
return ModuleOrErr.getError();
// Try to open the module documentation file. If it does not exist, ignore
// the error. However, pass though all other errors.
Scratch.clear();
llvm::sys::path::append(Scratch, DirName, ModuleDocFilename);
llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ModuleDocOrErr =
llvm::MemoryBuffer::getFile(StringRef(Scratch.data(), Scratch.size()));
if (!ModuleDocOrErr &&
ModuleDocOrErr.getError() != std::errc::no_such_file_or_directory) {
return ModuleDocOrErr.getError();
}
ModuleBuffer = std::move(ModuleOrErr.get());
if (ModuleDocOrErr)
ModuleDocBuffer = std::move(ModuleDocOrErr.get());
return std::error_code();
}
void DeclContext::localUncachedLookup(DeclarationName Name,
llvm::SmallVectorImpl<NamedDecl *> &Results) {
Results.clear();
// If there's no external storage, just perform a normal lookup and copy
// the results.
if (!hasExternalVisibleStorage() && !hasExternalLexicalStorage()) {
lookup_result LookupResults = lookup(Name);
Results.insert(Results.end(), LookupResults.first, LookupResults.second);
return;
}
// If we have a lookup table, check there first. Maybe we'll get lucky.
if (LookupPtr) {
StoredDeclsMap::iterator Pos = LookupPtr->find(Name);
if (Pos != LookupPtr->end()) {
Results.insert(Results.end(),
Pos->second.getLookupResult().first,
Pos->second.getLookupResult().second);
return;
}
}
// Slow case: grovel through the declarations in our chain looking for
// matches.
for (Decl *D = FirstDecl; D; D = D->getNextDeclInContext()) {
if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
if (ND->getDeclName() == Name)
Results.push_back(ND);
}
}
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();
}
llvm::StringRef
ParserImpl::MergeTokensUntil(const unsigned int* toks,
unsigned int num_toks,
SourceLocation* start,
SourceLocation* end,
llvm::SmallVectorImpl<char>& buffer,
bool stop_at_eos,
bool stop_at_ws)
{
buffer.clear();
*start = *end = m_token.getLocation();
for (;;)
{
// If we found one of the tokens, stop.
for (unsigned i = 0; i < num_toks; ++i)
{
if (m_token.is(toks[i]))
goto done;
}
// If we hit end of statement, stop.
if (stop_at_eos && m_token.isEndOfStatement())
break;
// Turn the token back into characters.
// The first if's are optimizations for common cases.
llvm::StringRef data;
if (m_token.isLiteral())
{
data = m_token.getLiteral();
}
else if (m_token.is(Token::identifier) || m_token.is(Token::label))
{
IdentifierInfo* ii = m_token.getIdentifierInfo();
data = ii->getName();
}
else
{
// Get the raw data from the source manager.
SourceManager& smgr = m_preproc.getSourceManager();
data =
llvm::StringRef(smgr.getCharacterData(m_token.getLocation()),
m_token.getLength());
}
buffer.append(data.begin(), data.end());
*end = m_token.getEndLocation();
ConsumeAnyToken();
// If we hit a token with leading space, stop.
// We do this down here in case the first token had preceding ws.
if (stop_at_ws && m_token.hasLeadingSpace())
break;
}
done:
return llvm::StringRef(buffer.data(), buffer.size());
}
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());
}
}
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);
}
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;
}
StringRef ObjCSelector::getString(llvm::SmallVectorImpl<char> &scratch) const {
// Fast path for zero-argument selectors.
if (getNumArgs() == 0) {
auto name = getSelectorPieces()[0];
if (name.empty())
return "";
return name.str();
}
scratch.clear();
llvm::raw_svector_ostream os(scratch);
os << *this;
return os.str();
}
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 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;
}
void
HostThreadFreeBSD::GetName(lldb::tid_t tid, llvm::SmallVectorImpl<char> &name)
{
name.clear();
int pid = Host::GetCurrentProcessID();
struct kinfo_proc *kp = nullptr, *nkp;
size_t len = 0;
int error;
int ctl[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID | KERN_PROC_INC_THREAD, (int)pid};
while (1)
{
error = sysctl(ctl, 4, kp, &len, nullptr, 0);
if (kp == nullptr || (error != 0 && errno == ENOMEM))
{
// Add extra space in case threads are added before next call.
len += sizeof(*kp) + len / 10;
nkp = (struct kinfo_proc *)realloc(kp, len);
if (nkp == nullptr)
{
free(kp);
return;
}
kp = nkp;
continue;
}
if (error != 0)
len = 0;
break;
}
for (size_t i = 0; i < len / sizeof(*kp); i++)
{
if (kp[i].ki_tid == (lwpid_t)tid)
{
name.append(kp[i].ki_tdname, kp[i].ki_tdname + strlen(kp[i].ki_tdname));
break;
}
}
free(kp);
}
/// If AI is the version of an initializer where we pass in either an apply or
/// an alloc_ref to initialize in place, validate that we are able to continue
/// optimizing and return To
static bool getDeadInstsAfterInitializerRemoved(
ApplyInst *AI, llvm::SmallVectorImpl<SILInstruction *> &ToDestroy) {
assert(ToDestroy.empty() && "We assume that ToDestroy is empty, so on "
"failure we can clear without worrying about the "
"caller accumulating and thus our eliminating "
"passed in state.");
SILValue Arg0 = AI->getArgument(0);
if (Arg0->getType().isExistentialType()) {
// This is a version of the initializer which receives a pre-allocated
// buffer as first argument. To completely eliminate the allocation, we must
// destroy the extra allocations as well as the initializer,
if (auto *Result = dyn_cast<ApplyInst>(Arg0)) {
ToDestroy.emplace_back(Result);
return true;
}
return false;
}
if (auto *ARI = dyn_cast<AllocRefInst>(Arg0)) {
if (all_of(ARI->getUses(), [&](Operand *Op) -> bool {
if (Op->getUser() == AI)
return true;
if (auto *SRI = dyn_cast<StrongReleaseInst>(Op->getUser())) {
ToDestroy.emplace_back(SRI);
return true;
}
return false;
})) {
return true;
}
}
// We may have added elements to the array before we failed. To avoid such a
// problem, we clear the out array here. We assert at the beginning that the
// out array is empty, so this is safe.
ToDestroy.clear();
return true;
}
void DeclExtractor::EnforceInitOrder(llvm::SmallVectorImpl<Stmt*>& Stmts){
Scope* TUScope = m_Sema->TUScope;
DeclContext* TUDC = static_cast<DeclContext*>(TUScope->getEntity());
// We can't PushDeclContext, because we don't have scope.
Sema::ContextRAII pushedDC(*m_Sema, TUDC);
std::string FunctionName = "__fd";
createUniqueName(FunctionName);
IdentifierInfo& IIFD = m_Context->Idents.get(FunctionName);
SourceLocation Loc;
NamedDecl* ND = m_Sema->ImplicitlyDefineFunction(Loc, IIFD, TUScope);
if (FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(ND)) {
FD->setImplicit(false); // Better for debugging
// Add a return statement if it doesn't exist
if (!isa<ReturnStmt>(Stmts.back())) {
Sema::ContextRAII pushedDC(*m_Sema, FD);
// Generate the return statement:
// First a literal 0, then the return taking that literal.
// One bit is enough:
llvm::APInt ZeroInt(m_Context->getIntWidth(m_Context->IntTy), 0,
/*isSigned=*/true);
IntegerLiteral* ZeroLit
= IntegerLiteral::Create(*m_Context, ZeroInt, m_Context->IntTy,
SourceLocation());
Stmts.push_back(m_Sema->ActOnReturnStmt(ZeroLit->getExprLoc(),
ZeroLit).take());
}
// Wrap Stmts into a function body.
llvm::ArrayRef<Stmt*> StmtsRef(Stmts.data(), Stmts.size());
CompoundStmt* CS = new (*m_Context)CompoundStmt(*m_Context, StmtsRef,
Loc, Loc);
FD->setBody(CS);
// We know the transaction is closed, but it is safe.
getTransaction()->forceAppend(FD);
// Create the VarDecl with the init
std::string VarName = "__vd";
createUniqueName(VarName);
IdentifierInfo& IIVD = m_Context->Idents.get(VarName);
VarDecl* VD = VarDecl::Create(*m_Context, TUDC, Loc, Loc, &IIVD,
FD->getReturnType(), (TypeSourceInfo*)0,
SC_None);
LookupResult R(*m_Sema, FD->getDeclName(), Loc, Sema::LookupMemberName);
R.addDecl(FD);
CXXScopeSpec CSS;
Expr* UnresolvedLookup
= m_Sema->BuildDeclarationNameExpr(CSS, R, /*ADL*/ false).take();
Expr* TheCall = m_Sema->ActOnCallExpr(TUScope, UnresolvedLookup, Loc,
MultiExprArg(), Loc).take();
assert(VD && TheCall && "Missing VD or its init!");
VD->setInit(TheCall);
// We know the transaction is closed, but it is safe.
getTransaction()->forceAppend(VD); // Add it to the transaction for codegenning
TUDC->addHiddenDecl(VD);
Stmts.clear();
return;
}
llvm_unreachable("Must be able to enforce init order.");
}