38#include "llvm/ExecutionEngine/JITSymbol.h"
39#include "llvm/ExecutionEngine/Orc/LLJIT.h"
40#include "llvm/IR/Module.h"
41#include "llvm/Support/Errc.h"
42#include "llvm/Support/ErrorHandling.h"
43#include "llvm/Support/raw_ostream.h"
44#include "llvm/TargetParser/Host.h"
58 if (!Jobs.
size() || !isa<driver::Command>(*Jobs.
begin()))
59 return llvm::createStringError(llvm::errc::not_supported,
60 "Driver initialization failed. "
61 "Unable to create a driver job");
65 if (llvm::StringRef(
Cmd->getCreator().getName()) !=
"clang")
66 return llvm::createStringError(llvm::errc::not_supported,
67 "Driver initialization failed");
69 return &
Cmd->getArguments();
73CreateCI(
const llvm::opt::ArgStringList &Argv) {
79 auto PCHOps = Clang->getPCHContainerOperations();
80 PCHOps->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
81 PCHOps->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
89 Clang->getInvocation(),
llvm::ArrayRef(Argv.begin(), Argv.size()), Diags);
92 if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
93 Clang->getHeaderSearchOpts().ResourceDir.empty())
94 Clang->getHeaderSearchOpts().ResourceDir =
98 Clang->createDiagnostics();
99 if (!Clang->hasDiagnostics())
100 return llvm::createStringError(llvm::errc::not_supported,
101 "Initialization failed. "
102 "Unable to create diagnostics engine");
106 return llvm::createStringError(llvm::errc::not_supported,
107 "Initialization failed. "
108 "Unable to flush diagnostics");
111 llvm::MemoryBuffer *MB = llvm::MemoryBuffer::getMemBuffer(
"").release();
112 Clang->getPreprocessorOpts().addRemappedFile(
"<<< inputs >>>", MB);
115 Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
116 if (!Clang->hasTarget())
117 return llvm::createStringError(llvm::errc::not_supported,
118 "Initialization failed. "
119 "Target is missing");
121 Clang->getTarget().adjust(Clang->getDiagnostics(), Clang->getLangOpts());
125 Clang->getCodeGenOpts().ClearASTBeforeBackend =
false;
127 Clang->getFrontendOpts().DisableFree =
false;
128 Clang->getCodeGenOpts().DisableFree =
false;
129 return std::move(Clang);
135IncrementalCompilerBuilder::create(std::string TT,
136 std::vector<const char *> &ClangArgv) {
140 std::string MainExecutableName =
141 llvm::sys::fs::getMainExecutable(
nullptr,
nullptr);
143 ClangArgv.insert(ClangArgv.begin(), MainExecutableName.c_str());
150 ClangArgv.insert(ClangArgv.end(),
"-Xclang");
151 ClangArgv.insert(ClangArgv.end(),
"-fincremental-extensions");
152 ClangArgv.insert(ClangArgv.end(),
"-c");
156 ClangArgv.push_back(
"<<< inputs >>>");
167 Driver.setCheckInputsExist(
false);
169 std::unique_ptr<driver::Compilation> Compilation(Driver.BuildCompilation(RF));
171 if (Compilation->
getArgs().hasArg(driver::options::OPT_v))
172 Compilation->
getJobs().
Print(llvm::errs(),
"\n",
false);
174 auto ErrOrCC1Args = GetCC1Arguments(&Diags, Compilation.get());
175 if (
auto Err = ErrOrCC1Args.takeError())
176 return std::move(Err);
178 return CreateCI(**ErrOrCC1Args);
183 std::vector<const char *> Argv;
184 Argv.reserve(5 + 1 + UserArgs.size());
185 Argv.push_back(
"-xc++");
186 Argv.insert(Argv.end(), UserArgs.begin(), UserArgs.end());
188 std::string TT = TargetTriple ? *TargetTriple : llvm::sys::getProcessTriple();
189 return IncrementalCompilerBuilder::create(TT, Argv);
193IncrementalCompilerBuilder::createCuda(
bool device) {
194 std::vector<const char *> Argv;
195 Argv.reserve(5 + 4 + UserArgs.size());
197 Argv.push_back(
"-xcuda");
199 Argv.push_back(
"--cuda-device-only");
201 Argv.push_back(
"--cuda-host-only");
203 std::string SDKPathArg =
"--cuda-path=";
204 if (!CudaSDKPath.empty()) {
205 SDKPathArg += CudaSDKPath;
206 Argv.push_back(SDKPathArg.c_str());
209 std::string ArchArg =
"--offload-arch=";
210 if (!OffloadArch.empty()) {
211 ArchArg += OffloadArch;
212 Argv.push_back(ArchArg.c_str());
215 Argv.insert(Argv.end(), UserArgs.begin(), UserArgs.end());
217 std::string TT = TargetTriple ? *TargetTriple : llvm::sys::getProcessTriple();
218 return IncrementalCompilerBuilder::create(TT, Argv);
223 return IncrementalCompilerBuilder::createCuda(
true);
228 return IncrementalCompilerBuilder::createCuda(
false);
233 llvm::ErrorAsOutParameter EAO(&Err);
234 auto LLVMCtx = std::make_unique<llvm::LLVMContext>();
235 TSCtx = std::make_unique<llvm::orc::ThreadSafeContext>(std::move(LLVMCtx));
236 IncrParser = std::make_unique<IncrementalParser>(*
this, std::move(CI),
237 *TSCtx->getContext(), Err);
242 if (llvm::Error Err = IncrExecutor->cleanUp())
243 llvm::report_fatal_error(
244 llvm::Twine(
"Failed to clean up IncrementalExecutor: ") +
254 void *__clang_Interpreter_SetValueWithAlloc(void*, void*, void*);
255 void __clang_Interpreter_SetValueNoAlloc(void*, void*, void*);
256 void __clang_Interpreter_SetValueNoAlloc(void*, void*, void*, void*);
257 void __clang_Interpreter_SetValueNoAlloc(void*, void*, void*, float);
258 void __clang_Interpreter_SetValueNoAlloc(void*, void*, void*, double);
259 void __clang_Interpreter_SetValueNoAlloc(void*, void*, void*, long double);
260 void __clang_Interpreter_SetValueNoAlloc(void*,void*,void*,unsigned long long);
261 struct __clang_Interpreter_NewTag{} __ci_newtag;
262 void* operator new(__SIZE_TYPE__, void* __p, __clang_Interpreter_NewTag) noexcept;
263 template <class T, class = T (*)() /*disable for arrays*/>
264 void __clang_Interpreter_SetValueCopyArr(T* Src, void* Placement, unsigned long Size) {
265 for (auto Idx = 0; Idx < Size; ++Idx)
266 new ((void*)(((T*)Placement) + Idx), __ci_newtag) T(Src[Idx]);
268 template <class T, unsigned long N>
269 void __clang_Interpreter_SetValueCopyArr(const T (*Src)[N], void* Placement, unsigned long Size) {
270 __clang_Interpreter_SetValueCopyArr(Src[0], Placement, Size);
277 llvm::Error Err = llvm::Error::success();
279 std::unique_ptr<Interpreter>(
new Interpreter(std::move(CI), Err));
281 return std::move(Err);
287 return PTU.takeError();
288 Interp->markUserCodeStart();
290 Interp->ValuePrintingInfo.resize(4);
291 return std::move(Interp);
296 std::unique_ptr<CompilerInstance> DCI) {
299 std::make_unique<llvm::vfs::InMemoryFileSystem>();
301 std::make_unique<llvm::vfs::OverlayFileSystem>(
302 llvm::vfs::getRealFileSystem());
303 OverlayVFS->pushOverlay(IMVFS);
304 CI->createFileManager(OverlayVFS);
307 if (
auto E = Interp.takeError())
310 llvm::Error Err = llvm::Error::success();
311 auto DeviceParser = std::make_unique<IncrementalCUDADeviceParser>(
312 **Interp, std::move(DCI), *(*Interp)->IncrParser.get(),
313 *(*Interp)->TSCtx->getContext(), IMVFS, Err);
315 return std::move(Err);
317 (*Interp)->DeviceParser = std::move(DeviceParser);
323 return IncrParser->getCI();
327 return IncrParser->getCI();
333 return std::move(Err);
336 return IncrExecutor->GetExecutionEngine();
347void Interpreter::markUserCodeStart() {
348 assert(!InitPTUSize &&
"We only do this once");
349 InitPTUSize = IncrParser->getPTUs().size();
352size_t Interpreter::getEffectivePTUSize()
const {
353 std::list<PartialTranslationUnit> &PTUs = IncrParser->getPTUs();
354 assert(PTUs.size() >= InitPTUSize &&
"empty PTU list?");
355 return PTUs.size() - InitPTUSize;
363 auto DevicePTU = DeviceParser->Parse(Code);
364 if (
auto E = DevicePTU.takeError())
372 return IncrParser->Parse(Code);
377 if (TT == llvm::sys::getProcessTriple())
379 return llvm::orc::JITTargetMachineBuilder::detectHost();
382 return llvm::orc::JITTargetMachineBuilder(llvm::Triple(TT));
389 return JTMB.takeError();
395 return llvm::make_error<llvm::StringError>(
"Operation failed. "
396 "Execution engine exists",
401 return JB.takeError();
402 llvm::Error Err = llvm::Error::success();
403 auto Executor = std::make_unique<IncrementalExecutor>(*TSCtx, **JB, Err);
405 IncrExecutor = std::move(Executor);
420 if (
auto Err = IncrExecutor->addModule(
T))
423 if (
auto Err = IncrExecutor->runCtors())
426 return llvm::Error::success();
431 auto PTU =
Parse(Code);
433 return PTU.takeError();
435 if (llvm::Error Err =
Execute(*PTU))
443 *
V = std::move(LastValue);
445 return llvm::Error::success();
451 return llvm::make_error<llvm::StringError>(
"Operation failed. "
452 "No execution engine",
454 llvm::StringRef MangledName = IncrParser->GetMangledName(GD);
461 return llvm::make_error<llvm::StringError>(
"Operation failed. "
462 "No execution engine",
471 return llvm::make_error<llvm::StringError>(
"Operation failed. "
472 "No execution engine",
480 std::list<PartialTranslationUnit> &PTUs = IncrParser->getPTUs();
481 if (N > getEffectivePTUSize())
482 return llvm::make_error<llvm::StringError>(
"Operation failed. "
485 for (
unsigned I = 0; I < N; I++) {
487 if (llvm::Error Err = IncrExecutor->removeModule(PTUs.back()))
491 IncrParser->CleanUpPTU(PTUs.back());
494 return llvm::Error::success();
500 return EE.takeError();
502 auto &DL = EE->getDataLayout();
504 if (
auto DLSG = llvm::orc::DynamicLibrarySearchGenerator::Load(
505 name, DL.getGlobalPrefix()))
506 EE->getMainJITDylib().addGenerator(std::move(*DLSG));
508 return DLSG.takeError();
510 return llvm::Error::success();
515 assert(CXXRD &&
"Cannot compile a destructor for a nullptr");
516 if (
auto Dtor = Dtors.find(CXXRD); Dtor != Dtors.end())
517 return Dtor->getSecond();
520 return llvm::orc::ExecutorAddr{};
525 llvm::StringRef Name =
529 return AddrOrErr.takeError();
531 Dtors[CXXRD] = *AddrOrErr;
536 "__clang_Interpreter_SetValueNoAlloc",
537 "__clang_Interpreter_SetValueWithAlloc",
538 "__clang_Interpreter_SetValueCopyArr",
"__ci_newtag"};
540static std::unique_ptr<RuntimeInterfaceBuilder>
545 if (llvm::all_of(ValuePrintingInfo, [](
Expr *E) {
return E !=
nullptr; }))
551 auto LookupInterface = [&](
Expr *&
Interface, llvm::StringRef Name) {
554 RedeclarationKind::ForVisibleRedeclaration);
564 if (!LookupInterface(ValuePrintingInfo[
NoAlloc],
567 if (!LookupInterface(ValuePrintingInfo[
WithAlloc],
570 if (!LookupInterface(ValuePrintingInfo[
CopyArray],
573 if (!LookupInterface(ValuePrintingInfo[
NewTag],
582class InterfaceKindVisitor
583 :
public TypeVisitor<InterfaceKindVisitor, Interpreter::InterfaceKind> {
584 friend class InProcessRuntimeInterfaceBuilder;
593 : Ctx(Ctx), S(S), E(E) {}
596 return Interpreter::InterfaceKind::WithAlloc;
601 return Interpreter::InterfaceKind::WithAlloc;
606 return Interpreter::InterfaceKind::CopyArray;
612 return Interpreter::InterfaceKind::NoAlloc;
617 return Interpreter::InterfaceKind::NoAlloc;
622 assert(!AddrOfE.
isInvalid() &&
"Can not create unary expression");
623 Args.push_back(AddrOfE.
get());
624 return Interpreter::InterfaceKind::NoAlloc;
633 HandleIntegralOrEnumType(Ty);
638 return Interpreter::InterfaceKind::NoAlloc;
642 HandleIntegralOrEnumType(Ty);
643 return Interpreter::InterfaceKind::NoAlloc;
649 void HandleIntegralOrEnumType(
const Type *Ty) {
653 assert(!CastedExpr.
isInvalid() &&
"Cannot create cstyle cast expr");
654 Args.push_back(CastedExpr.
get());
657 void HandlePtrType(
const Type *Ty) {
661 assert(!CastedExpr.
isInvalid() &&
"Can not create cstyle cast expression");
662 Args.push_back(CastedExpr.
get());
673 : Interp(Interp), Ctx(
C), S(S) {}
675 TransformExprFunction *getPrintValueTransformer()
override {
676 return &transformForValuePrinting;
683 auto *B =
static_cast<InProcessRuntimeInterfaceBuilder *
>(Builder);
686 if (
auto *EWC = llvm::dyn_cast_if_present<ExprWithCleanups>(E))
687 E = EWC->getSubExpr();
689 InterfaceKindVisitor Visitor(B->Ctx, B->S, E);
692 for (
Expr *E : FixedArgs)
693 Visitor.Args.push_back(E);
700 DesugaredTy = B->Ctx.getLValueReferenceType(DesugaredTy);
701 Ty = B->Ctx.getLValueReferenceType(Ty);
707 Visitor.Args.push_back(TypeArg);
713 case Interpreter::InterfaceKind::WithAlloc:
714 case Interpreter::InterfaceKind::CopyArray: {
719 .getValuePrintingInfo()[Interpreter::InterfaceKind::WithAlloc],
721 assert(!AllocCall.
isInvalid() &&
"Can't create runtime interface call!");
728 auto *Dtor = B->S.LookupDestructor(RD);
729 Dtor->addAttr(UsedAttr::CreateImplicit(B->Ctx));
730 B->Interp.getCompilerInstance()->getASTConsumer().HandleTopLevelDecl(
735 if (Kind == Interpreter::InterfaceKind::CopyArray) {
736 const auto *ConstantArrTy =
737 cast<ConstantArrayType>(DesugaredTy.
getTypePtr());
738 size_t ArrSize = B->Ctx.getConstantArrayElementCount(ConstantArrTy);
740 Expr *Args[] = {E, AllocCall.
get(), ArrSizeExpr};
741 return B->S.ActOnCallExpr(
744 .getValuePrintingInfo()[Interpreter::InterfaceKind::CopyArray],
749 B->Interp.getValuePrintingInfo()[Interpreter::InterfaceKind::NewTag]};
758 "Can't create runtime placement new call!");
760 return B->S.ActOnFinishFullExpr(CXXNewCall.
get(),
764 case Interpreter::InterfaceKind::NoAlloc: {
765 return B->S.ActOnCallExpr(
767 B->Interp.getValuePrintingInfo()[Interpreter::InterfaceKind::NoAlloc],
771 llvm_unreachable(
"Unhandled Interpreter::InterfaceKind");
777static std::unique_ptr<RuntimeInterfaceBuilder>
780 return std::make_unique<InProcessRuntimeInterfaceBuilder>(Interp, Ctx, S);
803 AddPrintValueCall = RuntimeIB->getPrintValueTransformer();
806 assert(AddPrintValueCall &&
807 "We don't have a runtime interface for pretty print!");
817 AddPrintValueCall(RuntimeIB.get(), E, {ThisInterp, OutValue});
853 QT = ET->getDecl()->getIntegerType();
857 llvm_unreachable(
"unknown type kind!");
858#define X(type, name) \
859 case BuiltinType::name: \
869 unsigned long long Val) {
896 VRef.setLongDouble(Val);
908 return operator new(__sz,
__p);
Defines the clang::ASTContext interface.
#define REPL_EXTERNAL_VISIBILITY
#define REPL_BUILTIN_TYPES
static std::unique_ptr< RuntimeInterfaceBuilder > createInProcessRuntimeInterfaceBuilder(Interpreter &Interp, ASTContext &Ctx, Sema &S)
static void SetValueDataBasedOnQualType(Value &V, unsigned long long Data)
const char *const Runtimes
REPL_EXTERNAL_VISIBILITY void __clang_Interpreter_SetValueNoAlloc(void *This, void *OutVal, void *OpaqueType, void *Val)
REPL_EXTERNAL_VISIBILITY void * __clang_Interpreter_SetValueWithAlloc(void *This, void *OutVal, void *OpaqueType)
static constexpr llvm::StringRef MagicRuntimeInterface[]
static llvm::Expected< llvm::orc::JITTargetMachineBuilder > createJITTargetMachineBuilder(const std::string &TT)
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
static __inline__ uint32_t volatile uint32_t * __p
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType UnsignedLongLongTy
This class is used for builtin types like 'int'.
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
Represents a C++ nested-name-specifier or a global scope specifier.
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
ASTContext & getASTContext() const
TargetOptions & getTargetOpts()
static std::string GetResourcesPath(const char *Argv0, void *MainAddr)
Get the directory where the compiler headers reside, relative to the compiler binary (found by the pa...
static bool CreateFromArgs(CompilerInvocation &Res, ArrayRef< const char * > CommandLineArgs, DiagnosticsEngine &Diags, const char *Argv0=nullptr)
Create a compiler invocation from a list of input options.
Represents the canonical version of C arrays with a specified constant size.
Used for handling and querying diagnostic IDs.
Options for controlling the compiler diagnostics engine.
Concrete class used by the front-end to report problems and issues.
void setSeverity(diag::kind Diag, diag::Severity Map, SourceLocation Loc)
This allows the client to specify that certain warnings are ignored.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
This represents one expression.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
Represents a prototype with parameter type info, e.g.
GlobalDecl - represents a global declaration.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
llvm::Expected< std::unique_ptr< CompilerInstance > > CreateCudaHost()
llvm::Expected< std::unique_ptr< CompilerInstance > > CreateCpp()
llvm::Expected< std::unique_ptr< CompilerInstance > > CreateCudaDevice()
static llvm::Expected< std::unique_ptr< llvm::orc::LLJITBuilder > > createDefaultJITBuilder(llvm::orc::JITTargetMachineBuilder JTMB)
Provides top-level interfaces for incremental compilation and execution.
llvm::Expected< llvm::orc::ExecutorAddr > getSymbolAddress(GlobalDecl GD) const
llvm::Error Execute(PartialTranslationUnit &T)
llvm::Expected< llvm::orc::LLJIT & > getExecutionEngine()
llvm::Expected< llvm::orc::ExecutorAddr > getSymbolAddressFromLinkerName(llvm::StringRef LinkerName) const
static llvm::Expected< std::unique_ptr< Interpreter > > createWithCUDA(std::unique_ptr< CompilerInstance > CI, std::unique_ptr< CompilerInstance > DCI)
const CompilerInstance * getCompilerInstance() const
virtual llvm::Expected< std::unique_ptr< llvm::orc::LLJITBuilder > > CreateJITBuilder(CompilerInstance &CI)
llvm::Expected< llvm::orc::ExecutorAddr > CompileDtorCall(CXXRecordDecl *CXXRD)
llvm::Error LoadDynamicLibrary(const char *name)
Link a dynamic library.
virtual std::unique_ptr< RuntimeInterfaceBuilder > FindRuntimeInterface()
llvm::Error ParseAndExecute(llvm::StringRef Code, Value *V=nullptr)
Interpreter(std::unique_ptr< CompilerInstance > CI, llvm::Error &Err)
Expr * SynthesizeExpr(Expr *E)
llvm::Error CreateExecutor()
static llvm::Expected< std::unique_ptr< Interpreter > > create(std::unique_ptr< CompilerInstance > CI)
llvm::Expected< PartialTranslationUnit & > Parse(llvm::StringRef Code)
llvm::Error Undo(unsigned N=1)
Undo N previous incremental inputs.
const ASTContext & getASTContext() const
Represents the results of name lookup.
bool empty() const
Return true if no decls were found.
A pointer to member type per C++ 8.3.3 - Pointers to members.
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
void * getAsOpaquePtr() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Base for LValueReferenceType and RValueReferenceType.
Generate glue code between the Interpreter's built-in runtime and user code.
Sema - This implements semantic analysis and AST building for C.
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
ASTContext & getASTContext() const
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, SourceLocation RParenLoc, Expr *Op)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
Encodes a location in the source.
A trivial tuple used to represent a source range.
SourceLocation getEndLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
std::string Triple
The name of the target triple to compile for.
void FlushDiagnostics(DiagnosticsEngine &Diags) const
FlushDiagnostics - Flush the buffered diagnostics to an given diagnostic engine.
A container of type source information.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
const T * castAs() const
Member-template castAs<specific type>.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool isFloatingType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isNullPtrType() const
bool isRecordType() const
Command - An executable path/name and argument vector to execute.
Compilation - A set of tasks to perform for a single driver invocation.
const llvm::opt::DerivedArgList & getArgs() const
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
JobList - A sequence of jobs to perform.
void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote, CrashReportInfo *CrashInfo=nullptr) const
Defines the clang::TargetInfo interface.
@ Ignored
Do not present this diagnostic, ignore it.
The JSON file list parser is used to communicate input to InstallAPI.
std::unique_ptr< DiagnosticOptions > CreateAndPopulateDiagOpts(ArrayRef< const char * > Argv)
@ Result
The result type of a method or function.
IntegerLiteral * IntegerLiteralExpr(ASTContext &C, uint64_t Val)
@ Dtor_Base
Base object dtor.
const FunctionProtoType * T
Expr * CStyleCastPtrExpr(Sema &S, QualType Ty, Expr *E)
@ Success
Template argument deduction was successful.
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
The class keeps track of various objects created as part of processing incremental inputs.