replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[libclang] Use lambdas instead of explicit structs when storing arguments. 

This boilerplate code was necessary to move arguments between threads in
C++98, lambdas make this much easier. No functionality change intended.

llvm-svn: 243227
This commit is contained in:
Benjamin Kramer 2015-07-25 20:55:44 +00:00
parent 54fcd62c6f
commit 11a9cd956a
4 changed files with 134 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

185
clang/tools/libclang/CIndex.cpp
View File

@ -2988,35 +2988,19 @@ clang_createTranslationUnitFromSourceFile(CXIndex CIdx,
Options);
}
struct ParseTranslationUnitInfo {
CXIndex CIdx;
const char *source_filename;
const char *const *command_line_args;
int num_command_line_args;
ArrayRef<CXUnsavedFile> unsaved_files;
unsigned options;
CXTranslationUnit *out_TU;
CXErrorCode &result;
};
static void clang_parseTranslationUnit_Impl(void *UserData) {
const ParseTranslationUnitInfo *PTUI =
static_cast<ParseTranslationUnitInfo *>(UserData);
CXIndex CIdx = PTUI->CIdx;
const char *source_filename = PTUI->source_filename;
const char * const *command_line_args = PTUI->command_line_args;
int num_command_line_args = PTUI->num_command_line_args;
unsigned options = PTUI->options;
CXTranslationUnit *out_TU = PTUI->out_TU;
static CXErrorCode
clang_parseTranslationUnit_Impl(CXIndex CIdx, const char *source_filename,
const char *const *command_line_args,
int num_command_line_args,
ArrayRef<CXUnsavedFile> unsaved_files,
unsigned options, CXTranslationUnit *out_TU) {
// Set up the initial return values.
if (out_TU)
*out_TU = nullptr;
// Check arguments.
if (!CIdx || !out_TU) {
PTUI->result = CXError_InvalidArguments;
return;
}
if (!CIdx || !out_TU)
return CXError_InvalidArguments;
CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
@ -3050,7 +3034,7 @@ static void clang_parseTranslationUnit_Impl(void *UserData) {
llvm::CrashRecoveryContextCleanupRegistrar<
std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
for (auto &UF : PTUI->unsaved_files) {
for (auto &UF : unsaved_files) {
std::unique_ptr<llvm::MemoryBuffer> MB =
llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));
@ -3109,10 +3093,8 @@ static void clang_parseTranslationUnit_Impl(void *UserData) {
/*UserFilesAreVolatile=*/true, ForSerialization, &ErrUnit));
// Early failures in LoadFromCommandLine may return with ErrUnit unset.
if (!Unit && !ErrUnit) {
PTUI->result = CXError_ASTReadError;
return;
}
if (!Unit && !ErrUnit)
return CXError_ASTReadError;
if (NumErrors != Diags->getClient()->getNumErrors()) {
// Make sure to check that 'Unit' is non-NULL.
@ -3120,12 +3102,11 @@ static void clang_parseTranslationUnit_Impl(void *UserData) {
printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get());
}
if (isASTReadError(Unit ? Unit.get() : ErrUnit.get())) {
PTUI->result = CXError_ASTReadError;
} else {
*PTUI->out_TU = MakeCXTranslationUnit(CXXIdx, Unit.release());
PTUI->result = *PTUI->out_TU ? CXError_Success : CXError_Failure;
}
if (isASTReadError(Unit ? Unit.get() : ErrUnit.get()))
return CXError_ASTReadError;
*out_TU = MakeCXTranslationUnit(CXXIdx, Unit.release());
return *out_TU ? CXError_Success : CXError_Failure;
}
CXTranslationUnit
@ -3165,18 +3146,14 @@ enum CXErrorCode clang_parseTranslationUnit2(
return CXError_InvalidArguments;
CXErrorCode result = CXError_Failure;
ParseTranslationUnitInfo PTUI = {
CIdx,
source_filename,
command_line_args,
num_command_line_args,
llvm::makeArrayRef(unsaved_files, num_unsaved_files),
options,
out_TU,
result};
auto ParseTranslationUnitImpl = [=, &result] {
result = clang_parseTranslationUnit_Impl(
CIdx, source_filename, command_line_args, num_command_line_args,
llvm::makeArrayRef(unsaved_files, num_unsaved_files), options, out_TU);
};
llvm::CrashRecoveryContext CRC;
if (!RunSafely(CRC, clang_parseTranslationUnit_Impl, &PTUI)) {
if (!RunSafely(CRC, ParseTranslationUnitImpl)) {
fprintf(stderr, "libclang: crash detected during parsing: {\n");
fprintf(stderr, " 'source_filename' : '%s'\n", source_filename);
fprintf(stderr, " 'command_line_args' : [");
@ -3199,7 +3176,7 @@ enum CXErrorCode clang_parseTranslationUnit2(
return CXError_Crashed;
} else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
if (CXTranslationUnit *TU = PTUI.out_TU)
if (CXTranslationUnit *TU = out_TU)
PrintLibclangResourceUsage(*TU);
}
@ -3210,27 +3187,15 @@ unsigned clang_defaultSaveOptions(CXTranslationUnit TU) {
return CXSaveTranslationUnit_None;
}
namespace {
struct SaveTranslationUnitInfo {
CXTranslationUnit TU;
const char *FileName;
unsigned options;
CXSaveError result;
};
}
static void clang_saveTranslationUnit_Impl(void *UserData) {
SaveTranslationUnitInfo *STUI =
static_cast<SaveTranslationUnitInfo*>(UserData);
CIndexer *CXXIdx = STUI->TU->CIdx;
static CXSaveError clang_saveTranslationUnit_Impl(CXTranslationUnit TU,
const char *FileName,
unsigned options) {
CIndexer *CXXIdx = TU->CIdx;
if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
setThreadBackgroundPriority();
bool hadError = cxtu::getASTUnit(STUI->TU)->Save(STUI->FileName);
STUI->result = hadError ? CXSaveError_Unknown : CXSaveError_None;
bool hadError = cxtu::getASTUnit(TU)->Save(FileName);
return hadError ? CXSaveError_Unknown : CXSaveError_None;
}
int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName,
@ -3249,16 +3214,19 @@ int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName,
if (!CXXUnit->hasSema())
return CXSaveError_InvalidTU;
SaveTranslationUnitInfo STUI = { TU, FileName, options, CXSaveError_None };
CXSaveError result;
auto SaveTranslationUnitImpl = [=, &result]() {
result = clang_saveTranslationUnit_Impl(TU, FileName, options);
};
if (!CXXUnit->getDiagnostics().hasUnrecoverableErrorOccurred() ||
getenv("LIBCLANG_NOTHREADS")) {
clang_saveTranslationUnit_Impl(&STUI);
SaveTranslationUnitImpl();
if (getenv("LIBCLANG_RESOURCE_USAGE"))
PrintLibclangResourceUsage(TU);
return STUI.result;
return result;
}
// We have an AST that has invalid nodes due to compiler errors.
@ -3266,7 +3234,7 @@ int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName,
llvm::CrashRecoveryContext CRC;
if (!RunSafely(CRC, clang_saveTranslationUnit_Impl, &STUI)) {
if (!RunSafely(CRC, SaveTranslationUnitImpl)) {
fprintf(stderr, "libclang: crash detected during AST saving: {\n");
fprintf(stderr, " 'filename' : '%s'\n", FileName);
fprintf(stderr, " 'options' : %d,\n", options);
@ -3278,7 +3246,7 @@ int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName,
PrintLibclangResourceUsage(TU);
}
return STUI.result;
return result;
}
void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) {
@ -3302,25 +3270,14 @@ unsigned clang_defaultReparseOptions(CXTranslationUnit TU) {
return CXReparse_None;
}
struct ReparseTranslationUnitInfo {
CXTranslationUnit TU;
ArrayRef<CXUnsavedFile> unsaved_files;
unsigned options;
CXErrorCode &result;
};
static void clang_reparseTranslationUnit_Impl(void *UserData) {
const ReparseTranslationUnitInfo *RTUI =
static_cast<ReparseTranslationUnitInfo *>(UserData);
CXTranslationUnit TU = RTUI->TU;
unsigned options = RTUI->options;
(void) options;
static CXErrorCode
clang_reparseTranslationUnit_Impl(CXTranslationUnit TU,
ArrayRef<CXUnsavedFile> unsaved_files,
unsigned options) {
// Check arguments.
if (isNotUsableTU(TU)) {
LOG_BAD_TU(TU);
RTUI->result = CXError_InvalidArguments;
return;
return CXError_InvalidArguments;
}
// Reset the associated diagnostics.
@ -3341,7 +3298,7 @@ static void clang_reparseTranslationUnit_Impl(void *UserData) {
llvm::CrashRecoveryContextCleanupRegistrar<
std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
for (auto &UF : RTUI->unsaved_files) {
for (auto &UF : unsaved_files) {
std::unique_ptr<llvm::MemoryBuffer> MB =
llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));
@ -3349,9 +3306,10 @@ static void clang_reparseTranslationUnit_Impl(void *UserData) {
if (!CXXUnit->Reparse(CXXIdx->getPCHContainerOperations(),
*RemappedFiles.get()))
RTUI->result = CXError_Success;
else if (isASTReadError(CXXUnit))
RTUI->result = CXError_ASTReadError;
return CXError_Success;
if (isASTReadError(CXXUnit))
return CXError_ASTReadError;
return CXError_Failure;
}
int clang_reparseTranslationUnit(CXTranslationUnit TU,
@ -3365,19 +3323,20 @@ int clang_reparseTranslationUnit(CXTranslationUnit TU,
if (num_unsaved_files && !unsaved_files)
return CXError_InvalidArguments;
CXErrorCode result = CXError_Failure;
ReparseTranslationUnitInfo RTUI = {
TU, llvm::makeArrayRef(unsaved_files, num_unsaved_files), options,
result};
CXErrorCode result;
auto ReparseTranslationUnitImpl = [=, &result]() {
result = clang_reparseTranslationUnit_Impl(
TU, llvm::makeArrayRef(unsaved_files, num_unsaved_files), options);
};
if (getenv("LIBCLANG_NOTHREADS")) {
clang_reparseTranslationUnit_Impl(&RTUI);
ReparseTranslationUnitImpl();
return result;
}
llvm::CrashRecoveryContext CRC;
if (!RunSafely(CRC, clang_reparseTranslationUnit_Impl, &RTUI)) {
if (!RunSafely(CRC, ReparseTranslationUnitImpl)) {
fprintf(stderr, "libclang: crash detected during reparsing\n");
cxtu::getASTUnit(TU)->setUnsafeToFree(true);
return CXError_Crashed;
@ -6063,16 +6022,6 @@ MarkMacroArgTokensVisitorDelegate(CXCursor cursor, CXCursor parent,
parent);
}
namespace {
struct clang_annotateTokens_Data {
CXTranslationUnit TU;
ASTUnit *CXXUnit;
CXToken *Tokens;
unsigned NumTokens;
CXCursor *Cursors;
};
}
/// \brief Used by \c annotatePreprocessorTokens.
/// \returns true if lexing was finished, false otherwise.
static bool lexNext(Lexer &Lex, Token &Tok,
@ -6192,13 +6141,9 @@ static void annotatePreprocessorTokens(CXTranslationUnit TU,
}
// This gets run a separate thread to avoid stack blowout.
static void clang_annotateTokensImpl(void *UserData) {
CXTranslationUnit TU = ((clang_annotateTokens_Data*)UserData)->TU;
ASTUnit *CXXUnit = ((clang_annotateTokens_Data*)UserData)->CXXUnit;
CXToken *Tokens = ((clang_annotateTokens_Data*)UserData)->Tokens;
const unsigned NumTokens = ((clang_annotateTokens_Data*)UserData)->NumTokens;
CXCursor *Cursors = ((clang_annotateTokens_Data*)UserData)->Cursors;
static void clang_annotateTokensImpl(CXTranslationUnit TU, ASTUnit *CXXUnit,
CXToken *Tokens, unsigned NumTokens,
CXCursor *Cursors) {
CIndexer *CXXIdx = TU->CIdx;
if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
setThreadBackgroundPriority();
@ -6334,11 +6279,12 @@ void clang_annotateTokens(CXTranslationUnit TU,
return;
ASTUnit::ConcurrencyCheck Check(*CXXUnit);
clang_annotateTokens_Data data = { TU, CXXUnit, Tokens, NumTokens, Cursors };
auto AnnotateTokensImpl = [=]() {
clang_annotateTokensImpl(TU, CXXUnit, Tokens, NumTokens, Cursors);
};
llvm::CrashRecoveryContext CRC;
if (!RunSafely(CRC, clang_annotateTokensImpl, &data,
GetSafetyThreadStackSize() * 2)) {
if (!RunSafely(CRC, AnnotateTokensImpl, GetSafetyThreadStackSize() * 2)) {
fprintf(stderr, "libclang: crash detected while annotating tokens\n");
}
}
@ -7187,14 +7133,13 @@ static unsigned SafetyStackThreadSize = 8 << 20;
namespace clang {
bool RunSafely(llvm::CrashRecoveryContext &CRC,
void (*Fn)(void*), void *UserData,
bool RunSafely(llvm::CrashRecoveryContext &CRC, llvm::function_ref<void()> Fn,
unsigned Size) {
if (!Size)
Size = GetSafetyThreadStackSize();
if (Size)
return CRC.RunSafelyOnThread(Fn, UserData, Size);
return CRC.RunSafely(Fn, UserData);
return CRC.RunSafelyOnThread(Fn, Size);
return CRC.RunSafely(Fn);
}
unsigned GetSafetyThreadStackSize() {

50
clang/tools/libclang/CIndexCodeCompletion.cpp
View File

@ -646,25 +646,12 @@ namespace {
};
}
extern "C" {
struct CodeCompleteAtInfo {
CXTranslationUnit TU;
const char *complete_filename;
unsigned complete_line;
unsigned complete_column;
ArrayRef<CXUnsavedFile> unsaved_files;
unsigned options;
CXCodeCompleteResults *result;
};
static void clang_codeCompleteAt_Impl(void *UserData) {
CodeCompleteAtInfo *CCAI = static_cast<CodeCompleteAtInfo*>(UserData);
CXTranslationUnit TU = CCAI->TU;
const char *complete_filename = CCAI->complete_filename;
unsigned complete_line = CCAI->complete_line;
unsigned complete_column = CCAI->complete_column;
unsigned options = CCAI->options;
static CXCodeCompleteResults *
clang_codeCompleteAt_Impl(CXTranslationUnit TU, const char *complete_filename,
unsigned complete_line, unsigned complete_column,
ArrayRef<CXUnsavedFile> unsaved_files,
unsigned options) {
bool IncludeBriefComments = options & CXCodeComplete_IncludeBriefComments;
CCAI->result = nullptr;
#ifdef UDP_CODE_COMPLETION_LOGGER
#ifdef UDP_CODE_COMPLETION_LOGGER_PORT
@ -676,12 +663,12 @@ static void clang_codeCompleteAt_Impl(void *UserData) {
if (cxtu::isNotUsableTU(TU)) {
LOG_BAD_TU(TU);
return;
return nullptr;
}
ASTUnit *AST = cxtu::getASTUnit(TU);
if (!AST)
return;
return nullptr;
CIndexer *CXXIdx = TU->CIdx;
if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
@ -692,7 +679,7 @@ static void clang_codeCompleteAt_Impl(void *UserData) {
// Perform the remapping of source files.
SmallVector<ASTUnit::RemappedFile, 4> RemappedFiles;
for (auto &UF : CCAI->unsaved_files) {
for (auto &UF : unsaved_files) {
std::unique_ptr<llvm::MemoryBuffer> MB =
llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
RemappedFiles.push_back(std::make_pair(UF.Filename, MB.release()));
@ -804,8 +791,10 @@ static void clang_codeCompleteAt_Impl(void *UserData) {
}
#endif
#endif
CCAI->result = Results;
return Results;
}
extern "C" {
CXCodeCompleteResults *clang_codeCompleteAt(CXTranslationUnit TU,
const char *complete_filename,
unsigned complete_line,
@ -821,25 +810,28 @@ CXCodeCompleteResults *clang_codeCompleteAt(CXTranslationUnit TU,
if (num_unsaved_files && !unsaved_files)
return nullptr;
CodeCompleteAtInfo CCAI = {TU, complete_filename, complete_line,
complete_column, llvm::makeArrayRef(unsaved_files, num_unsaved_files),
options, nullptr};
CXCodeCompleteResults *result;
auto CodeCompleteAtImpl = [=, &result]() {
result = clang_codeCompleteAt_Impl(
TU, complete_filename, complete_line, complete_column,
llvm::makeArrayRef(unsaved_files, num_unsaved_files), options);
};
if (getenv("LIBCLANG_NOTHREADS")) {
clang_codeCompleteAt_Impl(&CCAI);
return CCAI.result;
CodeCompleteAtImpl();
return result;
}
llvm::CrashRecoveryContext CRC;
if (!RunSafely(CRC, clang_codeCompleteAt_Impl, &CCAI)) {
if (!RunSafely(CRC, CodeCompleteAtImpl)) {
fprintf(stderr, "libclang: crash detected in code completion\n");
cxtu::getASTUnit(TU)->setUnsafeToFree(true);
return nullptr;
} else if (getenv("LIBCLANG_RESOURCE_USAGE"))
PrintLibclangResourceUsage(TU);
return CCAI.result;
return result;
}
unsigned clang_defaultCodeCompleteOptions(void) {

4
clang/tools/libclang/CIndexer.h
View File

@ -85,8 +85,8 @@ public:
/// threads when possible.
///
/// \return False if a crash was detected.
bool RunSafely(llvm::CrashRecoveryContext &CRC,
void (*Fn)(void*), void *UserData, unsigned Size = 0);
bool RunSafely(llvm::CrashRecoveryContext &CRC, llvm::function_ref<void()> Fn,
unsigned Size = 0);
/// \brief Set the thread priority to background.
/// FIXME: Move to llvm/Support.

146
clang/tools/libclang/Indexing.cpp
View File

@ -462,48 +462,24 @@ struct IndexSessionData {
: CIdx(cIdx), SkipBodyData(new SessionSkipBodyData) {}
};
struct IndexSourceFileInfo {
CXIndexAction idxAction;
CXClientData client_data;
IndexerCallbacks *index_callbacks;
unsigned index_callbacks_size;
unsigned index_options;
const char *source_filename;
const char *const *command_line_args;
int num_command_line_args;
ArrayRef<CXUnsavedFile> unsaved_files;
CXTranslationUnit *out_TU;
unsigned TU_options;
CXErrorCode &result;
};
} // anonymous namespace
static void clang_indexSourceFile_Impl(void *UserData) {
const IndexSourceFileInfo *ITUI =
static_cast<IndexSourceFileInfo *>(UserData);
CXIndexAction cxIdxAction = ITUI->idxAction;
CXClientData client_data = ITUI->client_data;
IndexerCallbacks *client_index_callbacks = ITUI->index_callbacks;
unsigned index_callbacks_size = ITUI->index_callbacks_size;
unsigned index_options = ITUI->index_options;
const char *source_filename = ITUI->source_filename;
const char * const *command_line_args = ITUI->command_line_args;
int num_command_line_args = ITUI->num_command_line_args;
CXTranslationUnit *out_TU = ITUI->out_TU;
unsigned TU_options = ITUI->TU_options;
static CXErrorCode clang_indexSourceFile_Impl(
CXIndexAction cxIdxAction, CXClientData client_data,
IndexerCallbacks *client_index_callbacks, unsigned index_callbacks_size,
unsigned index_options, const char *source_filename,
const char *const *command_line_args, int num_command_line_args,
ArrayRef<CXUnsavedFile> unsaved_files, CXTranslationUnit *out_TU,
unsigned TU_options) {
if (out_TU)
*out_TU = nullptr;
bool requestedToGetTU = (out_TU != nullptr);
if (!cxIdxAction) {
ITUI->result = CXError_InvalidArguments;
return;
return CXError_InvalidArguments;
}
if (!client_index_callbacks || index_callbacks_size == 0) {
ITUI->result = CXError_InvalidArguments;
return;
return CXError_InvalidArguments;
}
IndexerCallbacks CB;
@ -557,7 +533,7 @@ static void clang_indexSourceFile_Impl(void *UserData) {
CInvok(createInvocationFromCommandLine(*Args, Diags));
if (!CInvok)
return;
return CXError_Failure;
// Recover resources if we crash before exiting this function.
llvm::CrashRecoveryContextCleanupRegistrar<CompilerInvocation,
@ -565,7 +541,7 @@ static void clang_indexSourceFile_Impl(void *UserData) {
CInvokCleanup(CInvok.get());
if (CInvok->getFrontendOpts().Inputs.empty())
return;
return CXError_Failure;
typedef SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 8> MemBufferOwner;
std::unique_ptr<MemBufferOwner> BufOwner(new MemBufferOwner);
@ -574,7 +550,7 @@ static void clang_indexSourceFile_Impl(void *UserData) {
llvm::CrashRecoveryContextCleanupRegistrar<MemBufferOwner> BufOwnerCleanup(
BufOwner.get());
for (auto &UF : ITUI->unsaved_files) {
for (auto &UF : unsaved_files) {
std::unique_ptr<llvm::MemoryBuffer> MB =
llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
CInvok->getPreprocessorOpts().addRemappedFile(UF.Filename, MB.get());
@ -592,10 +568,8 @@ static void clang_indexSourceFile_Impl(void *UserData) {
ASTUnit *Unit = ASTUnit::create(CInvok.get(), Diags, CaptureDiagnostics,
/*UserFilesAreVolatile=*/true);
if (!Unit) {
ITUI->result = CXError_InvalidArguments;
return;
}
if (!Unit)
return CXError_InvalidArguments;
std::unique_ptr<CXTUOwner> CXTU(
new CXTUOwner(MakeCXTranslationUnit(CXXIdx, Unit)));
@ -653,38 +627,22 @@ static void clang_indexSourceFile_Impl(void *UserData) {
if (DiagTrap.hasErrorOccurred() && CXXIdx->getDisplayDiagnostics())
printDiagsToStderr(Unit);
if (isASTReadError(Unit)) {
ITUI->result = CXError_ASTReadError;
return;
}
if (isASTReadError(Unit))
return CXError_ASTReadError;
if (!Success)
return;
return CXError_Failure;
if (out_TU)
*out_TU = CXTU->takeTU();
ITUI->result = CXError_Success;
return CXError_Success;
}
//===----------------------------------------------------------------------===//
// clang_indexTranslationUnit Implementation
//===----------------------------------------------------------------------===//
namespace {
struct IndexTranslationUnitInfo {
CXIndexAction idxAction;
CXClientData client_data;
IndexerCallbacks *index_callbacks;
unsigned index_callbacks_size;
unsigned index_options;
CXTranslationUnit TU;
int result;
};
} // anonymous namespace
static void indexPreprocessingRecord(ASTUnit &Unit, IndexingContext &IdxCtx) {
Preprocessor &PP = Unit.getPreprocessor();
if (!PP.getPreprocessingRecord())
@ -728,27 +686,17 @@ static void indexDiagnostics(CXTranslationUnit TU, IndexingContext &IdxCtx) {
IdxCtx.handleDiagnosticSet(DiagSet);
}
static void clang_indexTranslationUnit_Impl(void *UserData) {
IndexTranslationUnitInfo *ITUI =
static_cast<IndexTranslationUnitInfo*>(UserData);
CXTranslationUnit TU = ITUI->TU;
CXClientData client_data = ITUI->client_data;
IndexerCallbacks *client_index_callbacks = ITUI->index_callbacks;
unsigned index_callbacks_size = ITUI->index_callbacks_size;
unsigned index_options = ITUI->index_options;
// Set up the initial return value.
ITUI->result = CXError_Failure;
static CXErrorCode clang_indexTranslationUnit_Impl(
CXIndexAction idxAction, CXClientData client_data,
IndexerCallbacks *client_index_callbacks, unsigned index_callbacks_size,
unsigned index_options, CXTranslationUnit TU) {
// Check arguments.
if (isNotUsableTU(TU)) {
LOG_BAD_TU(TU);
ITUI->result = CXError_InvalidArguments;
return;
return CXError_InvalidArguments;
}
if (!client_index_callbacks || index_callbacks_size == 0) {
ITUI->result = CXError_InvalidArguments;
return;
return CXError_InvalidArguments;
}
CIndexer *CXXIdx = TU->CIdx;
@ -777,7 +725,7 @@ static void clang_indexTranslationUnit_Impl(void *UserData) {
ASTUnit *Unit = cxtu::getASTUnit(TU);
if (!Unit)
return;
return CXError_Failure;
ASTUnit::ConcurrencyCheck Check(*Unit);
@ -797,7 +745,7 @@ static void clang_indexTranslationUnit_Impl(void *UserData) {
indexTranslationUnit(*Unit, *IndexCtx);
indexDiagnostics(TU, *IndexCtx);
ITUI->result = CXError_Success;
return CXError_Success;
}
//===----------------------------------------------------------------------===//
@ -969,28 +917,23 @@ int clang_indexSourceFile(CXIndexAction idxAction,
return CXError_InvalidArguments;
CXErrorCode result = CXError_Failure;
IndexSourceFileInfo ITUI = {
idxAction,
client_data,
index_callbacks,
index_callbacks_size,
index_options,
source_filename,
command_line_args,
num_command_line_args,
llvm::makeArrayRef(unsaved_files, num_unsaved_files),
out_TU,
TU_options,
result};
auto IndexSourceFileImpl = [=, &result]() {
result = clang_indexSourceFile_Impl(
idxAction, client_data, index_callbacks, index_callbacks_size,
index_options, source_filename, command_line_args,
num_command_line_args,
llvm::makeArrayRef(unsaved_files, num_unsaved_files), out_TU,
TU_options);
};
if (getenv("LIBCLANG_NOTHREADS")) {
clang_indexSourceFile_Impl(&ITUI);
IndexSourceFileImpl();
return result;
}
llvm::CrashRecoveryContext CRC;
if (!RunSafely(CRC, clang_indexSourceFile_Impl, &ITUI)) {
if (!RunSafely(CRC, IndexSourceFileImpl)) {
fprintf(stderr, "libclang: crash detected during indexing source file: {\n");
fprintf(stderr, " 'source_filename' : '%s'\n", source_filename);
fprintf(stderr, " 'command_line_args' : [");
@ -1030,24 +973,27 @@ int clang_indexTranslationUnit(CXIndexAction idxAction,
*Log << TU;
}
IndexTranslationUnitInfo ITUI = { idxAction, client_data, index_callbacks,
index_callbacks_size, index_options, TU,
0 };
CXErrorCode result;
auto IndexTranslationUnitImpl = [=, &result]() {
result = clang_indexTranslationUnit_Impl(
idxAction, client_data, index_callbacks, index_callbacks_size,
index_options, TU);
};
if (getenv("LIBCLANG_NOTHREADS")) {
clang_indexTranslationUnit_Impl(&ITUI);
return ITUI.result;
IndexTranslationUnitImpl();
return result;
}
llvm::CrashRecoveryContext CRC;
if (!RunSafely(CRC, clang_indexTranslationUnit_Impl, &ITUI)) {
if (!RunSafely(CRC, IndexTranslationUnitImpl)) {
fprintf(stderr, "libclang: crash detected during indexing TU\n");
return 1;
}
return ITUI.result;
return result;
}
void clang_indexLoc_getFileLocation(CXIdxLoc location,